diff --git a/.cirrus.yml.backup b/.cirrus.yml.backup deleted file mode 100644 index 3970103e..00000000 --- a/.cirrus.yml.backup +++ /dev/null @@ -1,20 +0,0 @@ -######################################################### -# Build arm64 wheels for OSX on Cirrus CI -######################################################### - -cirrus_wheels_macos_arm64_task: - name: Build macOS arm64 wheels. - macos_instance: - image: ghcr.io/cirruslabs/macos-monterey-xcode:13.3.1 - env: - PATH: /opt/homebrew/opt/python@3.10/bin:$PATH - CIBW_ARCHS_MACOS: arm64 - CIBW_TEST_COMMAND: "python -m flint.test" - install_pre_requirements_script: - - python3 -m venv venv - - venv/bin/pip install --upgrade pip - - venv/bin/pip install cibuildwheel==2.16.2 - run_cibuildwheel_script: - - venv/bin/cibuildwheel --platform macos - wheels_artifacts: - path: "wheelhouse/*" diff --git a/.coveragerc.meson b/.coveragerc.meson deleted file mode 100644 index a72fd709..00000000 --- a/.coveragerc.meson +++ /dev/null @@ -1,2 +0,0 @@ -[run] -plugins = coverage_plugin diff --git a/.coveragerc.setuptools b/.coveragerc.setuptools deleted file mode 100644 index d9a48b4b..00000000 --- a/.coveragerc.setuptools +++ /dev/null @@ -1,2 +0,0 @@ -[run] -plugins = Cython.Coverage diff --git a/.github/dependabot.yml b/.github/dependabot.yml deleted file mode 100644 index 0e8cc813..00000000 --- a/.github/dependabot.yml +++ /dev/null @@ -1,18 +0,0 @@ -# To get started with Dependabot version updates, you'll need to specify which -# package ecosystems to update and where the package manifests are located. -# Please see the documentation for all configuration options: -# https://docs.github.com/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file - -version: 2 -updates: - - package-ecosystem: github-actions - directory: "/" - schedule: - interval: "monthly" - groups: - minor-patch-dependencies: - patterns: - - "*" - update-types: - - "patch" - - "minor" diff --git a/.github/workflows/buildwheel.yml b/.github/workflows/buildwheel.yml deleted file mode 100644 index 42cf56c8..00000000 --- a/.github/workflows/buildwheel.yml +++ /dev/null @@ -1,359 +0,0 @@ -name: Build - -on: [push, pull_request] - -jobs: - build_wheels: - name: Build wheels for ${{ matrix.os }} - runs-on: ${{ matrix.os }} - continue-on-error: true - strategy: - fail-fast: false - matrix: - os: [ubuntu-22.04, ubuntu-22.04-arm, windows-2022, macos-15-intel, macos-14] - - steps: - - uses: actions/checkout@v6.0.2 - - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - - uses: msys2/setup-msys2@v2.30.0 - with: - msystem: mingw64 - if: ${{ startsWith( matrix.os , 'windows' ) }} - - # Install pkgconfig on Windows from choco rather than from msys and - # avoid using the Strawberry one. - - run: choco install -y --stoponfirstfailure --checksum 6004DF17818F5A6DBF19CB335CC92702 pkgconfiglite - if: ${{ startsWith( matrix.os , 'windows' ) }} - - # We have to set this here rather than in the cibuildwheel config - # This is probably something to do with \ vs / in paths... - - run: echo "PKG_CONFIG_PATH=${{ github.workspace }}/.local/lib/pkgconfig" >> $env:GITHUB_ENV - if: ${{ startsWith( matrix.os , 'windows' ) }} - - - name: Build wheels - uses: pypa/cibuildwheel@298ed2fb2c105540f5ed055e8a6ad78d82dd3a7e # v3.3.1 - env: - # override setting in pyproject.toml to use msys2 instead of msys64 bash - CIBW_BEFORE_ALL_WINDOWS: msys2 -c bin/cibw_before_all_windows.sh - - - uses: actions/upload-artifact@v5 - with: - name: wheels-${{ matrix.os }} - path: wheelhouse/*.whl - - build_sdist: - name: Build sdist - runs-on: ubuntu-22.04 - - steps: - - uses: actions/checkout@v6.0.2 - - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - - run: bin/install_latest_flint_ubuntu.sh - - run: pip install build - - run: python -m build --sdist - - - uses: actions/upload-artifact@v5 - with: - name: sdist - path: dist/*.tar.gz - - test_wheels: - needs: build_wheels - name: Test ${{ matrix.python-version }} wheel on ${{ matrix.os }} - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ - ubuntu-22.04, - ubuntu-24.04, - ubuntu-24.04-arm, - windows-2022, - windows-2025, - macos-15-intel, - macos-14, - macos-15, - ] - # This list to be kept in sync with python-requires in pyproject.toml. - python-version: ['3.11', '3.12', '3.13', '3.13t', '3.14', '3.14t', 'pypy3.11'] - - steps: - - uses: actions/setup-python@v6 - with: - python-version: ${{ matrix.python-version }} - allow-prereleases: true - - uses: actions/download-artifact@v7 - with: - path: wheelhouse - merge-multiple: true - - run: pip install --no-index --find-links wheelhouse python_flint - - # Check if the GIL is disabled in the free-threading build after import. - - run: | - python --version --version - which python - python -c "import sysconfig; print(sysconfig.get_config_var('Py_GIL_DISABLED'))" - python -c "import sys; print(getattr(sys, '_is_gil_enabled', lambda: True)())" - python -c "import sys; import flint; print(getattr(sys, '_is_gil_enabled', lambda: True)())" - - - run: python -m flint.test --verbose - - # On new enough Ubuntu we can build against the system deb. - test_pip_flint_deb: - name: Build on ${{ matrix.os }} - runs-on: ${{ matrix.os }} - strategy: - fail-fast: false - matrix: - os: [ubuntu-24.04] - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: sudo apt-get update - - run: sudo apt-get install libflint-dev - - run: pip install . - - run: python -m flint.test --verbose - - test_docs: - name: Test docs (build and doctest) - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: bin/install_latest_flint_ubuntu.sh - - run: pip install --upgrade pip - - run: pip install -r requirements-dev.txt - - run: spin run -- pytest --doctest-glob='*.rst' doc/source - - run: spin docs - - # Test build with minimum Cython and meson-python versions. - test_old_build_requires: - name: 'Test old Cython/meson-python' - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: sudo apt-get update - - run: sudo apt-get install libflint-dev - # The versions of cython and meson-python here should be kept in sync - # with those in pyproject.toml so that we test the stated minimum - # versions. - # - # We don't need to specify ninja as a requirement in pyproject.toml - # because without --no-build-isolation meson-python handles it - # automatically in get_requirements_for_build_wheel(). - - run: 'pip install "cython==3.0.11" "meson-python==0.18" "ninja<1.11"' - - run: pip install --no-build-isolation . - - run: python -m flint.test --verbose - - # For older Ubuntu we have to build Flint >= 3.0.0 - test_flint_releases: - name: Test flint ${{ matrix.flint-tag }} - runs-on: ubuntu-22.04 - strategy: - fail-fast: false - matrix: - # Supported Flint versions: - flint-tag: ['v3.0.1', 'v3.1.3-p1', 'v3.2.2', 'v3.3.1'] - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: bin/install_flint_ubuntu.sh ${{ matrix.flint-tag }} - - run: pip install . - - run: python -m flint.test --verbose - - # Test against flint main - test_flint_main: - name: Test flint main Linux x86-64 - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: bin/install_flint_ubuntu.sh main - # Need to disable flint version check to build against main - - run: pip install --config-settings=setup-args="-Dflint_version_check=false" . - - run: python -m flint.test --verbose - - # Test against flint main - test_flint_main_arm: - name: Test flint main Linux ARM - runs-on: ubuntu-24.04-arm - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: bin/install_flint_ubuntu.sh main - # Need to disable flint version check to build against main - - run: pip install --config-settings=setup-args="-Dflint_version_check=false" . - - run: python -m flint.test --verbose - - # Test that we can make a coverage build and report coverage - test_coverage_build_setuptools: - name: Test coverage setuptools build - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: sudo apt-get update - - run: sudo apt-get install libflint-dev - - run: pip install -r requirements-dev.txt - - run: bin/coverage_setuptools.sh - - # Test that we can make a coverage build and report coverage - test_coverage_build_meson: - name: Test coverage meson build - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.12' # does not work with 3.13 - - run: sudo apt-get update - - run: sudo apt-get install libflint-dev - - run: pip install -r requirements-dev.txt - - run: bin/coverage.sh - - # Run SymPy test suite against python-flint master - test_sympy: - name: Test SymPy ${{ matrix.sympy-version }} - runs-on: ubuntu-24.04 - strategy: - fail-fast: false - matrix: - sympy-version: ['1.13.1', '1.14.0'] - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: sudo apt-get update - - run: sudo apt-get install libflint-dev - - run: pip install . - - run: pip install pytest pytest-xdist hypothesis - - run: pip install sympy==${{ matrix.sympy-version }} - - run: python -c 'import sympy; sympy.test(parallel=True)' - - # Run SymPy master branch agains python-flint main - test_sympy_master: - name: Test SymPy master - runs-on: ubuntu-24.04 - steps: - - uses: actions/checkout@v6.0.2 - - uses: actions/setup-python@v6 - with: - python-version: '3.13' - - run: sudo apt-get update - - run: sudo apt-get install libflint-dev - - run: pip install . - - run: pip install pytest pytest-xdist hypothesis - - run: pip install git+https://github.com/sympy/sympy.git@master - - run: python -c 'import sympy; sympy.test(parallel=True)' - - # Push nightly wheels to Anaconda scientific-python nightly channel - # https://scientific-python.org/specs/spec-0004/ - # https://anaconda.org/scientific-python-nightly-wheels/python-flint - # https://github.com/scientific-python/upload-nightly-action/issues/111 - - nightly-wheels-upload: - name: Upload Anaconda Scientific Python nightly wheels - needs: [build_wheels] - # Run on push/merge to main - if: github.event_name == 'push' && github.ref == 'refs/heads/main' - runs-on: ubuntu-latest - - steps: - # Downloads all artifacts - - name: Download release artifacts - uses: actions/download-artifact@v7 - with: - path: wheelhouse - merge-multiple: true - - - name: Copy the wheels into dist - run: mkdir dist && cp wheelhouse/*.whl dist - - - name: Upload wheels - uses: scientific-python/upload-nightly-action@5748273c71e2d8d3a61f3a11a16421c8954f9ecf # 0.6.3 - with: - artifacts_path: dist - # This token is generated from anaconda.org - # https://github.com/scientific-python/upload-nightly-action/issues/111 - anaconda_nightly_upload_token: ${{ secrets.ANACONDA_ORG_UPLOAD_TOKEN }} - - # Deploy wheels and sdist to PyPI - - pypi_release: - name: Publish to PyPI - needs: [build_wheels, build_sdist] - # Run only when a tag is pushed to the flintlib/python-flint repo - if: "github.event_name == 'push' && startsWith(github.ref, 'refs/tags') && github.repository_owner == 'flintlib'" - environment: - name: pypi - url: https://pypi.org/p/python-flint - permissions: - id-token: write - runs-on: ubuntu-latest - - steps: - # Downloads all artifacts - - name: Download release artifacts - uses: actions/download-artifact@v7 - with: - path: wheelhouse - merge-multiple: true - - - name: Copy the PyPI files into dist - run: mkdir dist && cp wheelhouse/*.whl wheelhouse/*.tar.gz dist - - - name: Publish package on PyPI - # It is recommended to pin a commit hash here for security but it - # should be kept up to date. Possibly all actions and dependencies used - # by the build script should be pinned... - uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # v1.13.0 - - # Make a GitHub release - - github-publish: - name: Publish GitHub release - needs: pypi_release - runs-on: ubuntu-latest - permissions: - contents: write - - steps: - - uses: actions/checkout@v6.0.2 - - - name: Download sdist - uses: actions/download-artifact@v7 - with: - name: sdist - path: dist - - - name: Create GitHub release - env: - GH_TOKEN: ${{ github.token }} - run: > - gh release create ${{ github.ref_name }} dist/* - --title "python-flint ${{ github.ref_name }}" - --notes "https://github.com/flintlib/python-flint?tab=readme-ov-file#changelog" diff --git a/.github/workflows/ci-emscripten.yml b/.github/workflows/ci-emscripten.yml deleted file mode 100644 index 27f1741b..00000000 --- a/.github/workflows/ci-emscripten.yml +++ /dev/null @@ -1,107 +0,0 @@ -name: Run Pyodide CI - -on: - pull_request: - workflow_dispatch: - -env: - FORCE_COLOR: 3 - -concurrency: - group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }} - # cancel-in-progress: true - -jobs: - build: - runs-on: ubuntu-latest - env: - PYODIDE_VERSION: "https://github.com/pyodide/pyodide-build-environment-nightly/releases/download/20250523-emscripten_4.0.9/xbuildenv.tar.bz2" - PYTHON_VERSION: 3.13 # any 3.13.x version works - EMSCRIPTEN_VERSION: 4.0.9 - NODE_VERSION: 22 - steps: - - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v4.2.2 - - - name: Set up Python ${{ env.PYTHON_VERSION }} - uses: actions/setup-python@2e3e4b15a884dc73a63f962bff250a855150a234 # v5.4.0 - with: - python-version: ${{ env.PYTHON_VERSION }} - - - name: Set up Emscripten toolchain - uses: mymindstorm/setup-emsdk@6ab9eb1bda2574c4ddb79809fc9247783eaf9021 # v14 - with: - version: ${{ env.EMSCRIPTEN_VERSION }} - actions-cache-folder: emsdk-cache - - - name: Set up Node.js - uses: actions/setup-node@6044e13b5dc448c55e2357c09f80417699197238 # v6.2.0 - with: - node-version: ${{ env.NODE_VERSION }} - - - name: Install pyodide-build - run: | - pip install pyodide-build - pyodide xbuildenv install --url ${{ env.PYODIDE_VERSION }} - - - name: Restore WASM library directory from cache - id: cache-wasm-library-dir - uses: actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 - with: - path: ${{ github.workspace }}/wasm-library-dir - key: wasm-library-dir-${{ hashFiles('bin/pyodide_build_dependencies.sh', 'bin/build_variables.sh') }}-0 - - - name: Build GMP, MPFR and FLINT - if: steps.cache-wasm-library-dir.outputs.cache-hit != 'true' - env: - CFLAGS: "-fPIC" - run: bin/pyodide_build_dependencies.sh --wasm-library-dir ${{ github.workspace }}/wasm-library-dir - - - name: Persist WASM library directory to cache - uses: actions/cache/save@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 - with: - path: ${{ github.workspace }}/wasm-library-dir - key: wasm-library-dir-${{ hashFiles('bin/pyodide_build_dependencies.sh', 'bin/build_variables.sh') }}-0 - - - name: Restore python-flint build directory from cache - uses: actions/cache/restore@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 - with: - path: ${{ github.workspace }}/flint_wasm_build - key: flint-wasm-build-${{ hashFiles('**/meson.build', '**/pyproject.toml', '**/setup.py') }} - - - name: Build python-flint - env: - WASM_LIBRARY_DIR: ${{ github.workspace }}/wasm-library-dir - run: | - export PKG_CONFIG_PATH="${{ env.WASM_LIBRARY_DIR }}/lib/pkgconfig:${PKG_CONFIG_PATH}" - export CFLAGS="-I${{ env.WASM_LIBRARY_DIR }}/include ${CFLAGS:-}" - export LDFLAGS="-L${{ env.WASM_LIBRARY_DIR }}/lib -lflint -lmpfr -lgmp ${LDFLAGS:-}" - - echo "PKG_CONFIG_PATH=${PKG_CONFIG_PATH}" - echo "CFLAGS=${CFLAGS}" - echo "LDFLAGS=${LDFLAGS}" - - pkg-config --modversion python3 - pkg-config --modversion mpfr - pkg-config --modversion flint - - pyodide build -Cbuild-dir=flint_wasm_build -Csetup-args="-Dflint_version_check=false" - - - name: Persist python-flint build directory to cache - uses: actions/cache/save@cdf6c1fa76f9f475f3d7449005a359c84ca0f306 # v5.0.3 - with: - path: ${{ github.workspace }}/flint_wasm_build - key: flint-wasm-build-${{ hashFiles('**/meson.build', '**/pyproject.toml', '**/setup.py') }} - - - name: Set up Pyodide virtual environment and test python-flint - run: | - pyodide venv .venv-pyodide - - source .venv-pyodide/bin/activate - pip install dist/*.whl - - cd doc - - pip install pytest hypothesis - # Don't use the cache provider plugin, as it doesn't work with Pyodide - # right now: https://github.com/pypa/cibuildwheel/issues/1966 - pytest -svra -p no:cacheprovider --pyargs flint diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml deleted file mode 100644 index 235d0f9a..00000000 --- a/.github/workflows/lint.yml +++ /dev/null @@ -1,26 +0,0 @@ -name: Linting - -on: [push, pull_request] - -jobs: - lint: - runs-on: ubuntu-latest - strategy: - matrix: - python-version: ["3.12"] - steps: - - uses: actions/checkout@v6.0.2 - - - name: Set up Python ${{ matrix.python-version }} - uses: actions/setup-python@v6 - with: - python-version: ${{ matrix.python-version }} - - - name: Install dependencies - run: | - pip install uv - uv pip install cython-lint --upgrade --system - - - name: cython-lint - run: | - cython-lint src/ diff --git a/.gitignore b/.gitignore deleted file mode 100644 index 075ec3ce..00000000 --- a/.gitignore +++ /dev/null @@ -1,22 +0,0 @@ -build/* -build-install/* -dist/* -src/flint/**/*.c -src/flint/*.html -doc/build/* -fmake* -*.whl -*.pyc -*.pyd -*.so -__pycache__ -MANIFEST -.eggs -.local -*.egg-info -.coverage -*.swp -.python-version -*.DS_Store -.venv -.hypothesis diff --git a/.readthedocs.yaml b/.readthedocs.yaml deleted file mode 100644 index cb39cf02..00000000 --- a/.readthedocs.yaml +++ /dev/null @@ -1,45 +0,0 @@ -# .readthedocs.yaml -# Read the Docs configuration file -# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details - -# Required -version: 2 - -# Set the OS, Python version and other tools you might need -build: - os: ubuntu-24.04 - tools: - python: "3.12" - - apt_packages: - - libflint-dev - jobs: - pre_build: - - pip install . - - # Tried to use this to build latest version of FLINT but FLINT does not build - # in rtd for some reason. FLINT's configure seems to fail in all sorts of ways - # even though GMP and MPFR build fine. - # - # commands: - # - pip install -r requirements-dev.txt - # - bin/build_dependencies_unix.sh --use-gmp-github-mirror - # - spin build -- --pkg-config-path=.local/lib/pkgconfig -Dadd_flint_rpath=true - # - spin docs - # - mv doc/build/html $READTHEDOCS_OUTPUT/html - -# Build documentation in the "docs/" directory with Sphinx -sphinx: - configuration: doc/source/conf.py - -# Optionally build your docs in additional formats such as PDF and ePub -# formats: -# - pdf -# - epub - -# Optional but recommended, declare the Python requirements required -# to build your documentation -# See https://docs.readthedocs.io/en/stable/guides/reproducible-builds.html -python: - install: - - requirements: requirements-dev.txt diff --git a/LICENSE b/LICENSE deleted file mode 100644 index 43c2ad50..00000000 --- a/LICENSE +++ /dev/null @@ -1,22 +0,0 @@ -MIT License - -Copyright (c) 2014-2016 Fredrik Johansson - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. - diff --git a/MANIFEST.in b/MANIFEST.in deleted file mode 100644 index 9acf0362..00000000 --- a/MANIFEST.in +++ /dev/null @@ -1,7 +0,0 @@ -include LICENSE -include CHANGES -include README.md -recursive-include src/flint *.pxd *.pyx *.py -include doc/source/*.py -include doc/source/*.rst -include doc/Makefile diff --git a/README.md b/README.md deleted file mode 100644 index d6b38322..00000000 --- a/README.md +++ /dev/null @@ -1,512 +0,0 @@ -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 - -Installation ------------- - -Currently python-flint supports CPython versions 3.11-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` | ??? | `3.11-3.14` | `3.0-3.3` | `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 -========= - -Next release (0.9.0)... ------------------------ - -Contributors (0.9.0): - -- Rémy Oudompheng (RO) -- Agriya Khetarpal (AK) -- Oscar Benjamin (OB) -- Daniel Simmons-Marengo (DSM) - -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-359](https://github.com/flintlib/python-flint/pull/359), - Sort factorisations of all mpoly types. (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+. diff --git a/bin/activate b/bin/activate deleted file mode 100644 index 465c484f..00000000 --- a/bin/activate +++ /dev/null @@ -1,4 +0,0 @@ -export C_INCLUDE_PATH=$(pwd)/.local/include -export LIBRARY_PATH=$(pwd)/.local/lib -export LD_LIBRARY_PATH=$(pwd)/.local/lib -export PKG_CONFIG_PATH=$(pwd)/.local/lib/pkgconfig diff --git a/bin/all_rst_to_pxd.sh b/bin/all_rst_to_pxd.sh deleted file mode 100755 index 091d755e..00000000 --- a/bin/all_rst_to_pxd.sh +++ /dev/null @@ -1,154 +0,0 @@ -#!/usr/bin/env bash - -set -e - -if [ $# -eq 0 ] - then - echo "Usage: bin/all_rst_to_pxd.sh /path/to/flint/doc/source" - exit 1 -fi - -FLINT_DOC_DIR=$1 - -modules=( - "flint" - "mpoly" - # "thread_pool" - # "machine_vectors" - "gr" - "gr_domains" - "gr_generic" - "gr_implementing" - "gr_mat" - "gr_mpoly" - "gr_poly" - "gr_special" - "gr_vec" - "ulong_extras" - "fmpz" - # "fmpz_extras" - "fmpz_factor" - "fmpz_lll" - "fmpz_mat" - "fmpz_mpoly" - "fmpz_mpoly_factor" - "fmpz_mpoly_q" - "fmpz_poly" - "fmpz_poly_factor" - # "fmpz_poly_mat" - # "fmpz_poly_q" - "fmpz_vec" - # "long_extras" - # "longlong" - # "mpn_extras" - # "aprcl" - "arith" - # "fft" - # "fft_small" - # "qsieve" - "fmpq" - "fmpq_mat" - "fmpq_mpoly" - "fmpq_mpoly_factor" - "fmpq_poly" - "fmpq_vec" - "nmod" - "nmod_mat" - "nmod_mpoly" - "nmod_mpoly_factor" - "nmod_poly" - "nmod_poly_factor" - # "nmod_poly_mat" - "nmod_vec" - # "mpn_mod" - "fmpz_mod" - "fmpz_mod_mat" - "fmpz_mod_mpoly" - "fmpz_mod_mpoly_factor" - "fmpz_mod_poly" - "fmpz_mod_poly_factor" - "fmpz_mod_vec" - "dirichlet" - # "dlog" - # "bool_mat" - # "perm" - # "qfb" - # "nf" - # "nf_elem" - # "fmpzi" - # "qqbar" - "mag" - # "nfloat" - "arf" - # "acf" - "arb" - # "arb_calc" - "arb_fmpz_poly" - # "arb_fpwrap" - "arb_hypgeom" - "arb_mat" - "arb_poly" - "acb" - "acb_calc" - "acb_dft" - "acb_dirichlet" - "acb_elliptic" - "acb_hypgeom" - "acb_mat" - "acb_modular" - "acb_poly" - "acb_theta" - "bernoulli" - # "hypgeom" - "partitions" - # "ca" - # "ca_ext" - # "ca_field" - # "ca_mat" - # "ca_poly" - # "ca_vec" - # "calcium" - # "fexpr" - # "fexpr_builtin" - "fq" - # "fq_embed" - "fq_mat" - "fq_poly" - "fq_poly_factor" - # "fq_vec" - "fq_nmod" - # "fq_nmod_embed" - "fq_nmod_mat" - # "fq_nmod_mpoly" - # "fq_nmod_mpoly_factor" - "fq_nmod_poly" - "fq_nmod_poly_factor" - # "fq_nmod_vec" - "fq_zech" - # "fq_zech_embed" - "fq_zech_mat" - "fq_zech_poly" - "fq_zech_poly_factor" - # "fq_zech_vec" - "fq_default" - "fq_default_mat" - "fq_default_poly" - "fq_default_poly_factor" - # "padic" - # "padic_mat" - # "padic_poly" - # "qadic" - # "double_extras" - # "double_interval" - # "d_mat" - # "d_vec" - # "mpfr_mat" - # "mpfr_vec" -) - -for module in ${modules[@]}; do - echo "Processing $module" - bin/rst_to_pxd.py flint/$module \ - --flint-doc-dir=$FLINT_DOC_DIR \ - > src/flint/flintlib/functions/$module.pxd -done diff --git a/bin/build_dependencies_unix.sh b/bin/build_dependencies_unix.sh deleted file mode 100755 index 6dfdeb12..00000000 --- a/bin/build_dependencies_unix.sh +++ /dev/null @@ -1,395 +0,0 @@ -#!/usr/bin/env bash -# -# Build local installs of python-flint's dependencies. This should be run -# before attempting to build python-flint itself. - -set -o errexit - -# ------------------------------------------------------------------------- # -# # -# Supported options: # -# # -# --gmp gmp - build based on GMP (default) # -# --gmp mpir - build based on MPIR (no longer works) # -# --host - set the host (target) for GMP build # -# --patch-gmp-arm64 - apply patch to GMP for OSX arm64 # -# # -# ------------------------------------------------------------------------- # - -SKIP_GMP=no -SKIP_MPFR=no - -USE_GMP=gmp -PATCH_GMP_ARM64=no -BUILD_ARB=no - -while [[ $# -gt 0 ]] -do - key="$1" - case $key in - -h|--help) - echo "bin/download_dependencies.sh [options]" - echo - echo "Build local installs of python-flint's dependencies." - echo - echo "Supported options:" - echo " --help - show this help message" - echo " --host - set the host (target) for GMP build" - echo " --skip-gmp - skip building GMP" - echo " --skip-mpfr - skip building MPFR" - echo - echo "Legacy options:" - echo " --gmp gmp - build based on GMP (default)" - echo " --gmp mpir - build based on MPIR (no longer works)" - echo " --patch-gmp-arm64 - apply patch to GMP 6.2.1 for OSX arm64" - echo " --patch-C23 - apply patch to GMP 6.3.0 for C23 compatibility" - echo " --arb - build Arb (only needed for flint < 3.0.0)" - echo - exit - ;; - --host) - # e.g. --host x86_64-unknown-linux-gnu - # or --host x86_64-apple-darwin - HOST_ARG="$2" - shift - shift - ;; - --gmp) - # e.g. --gmp gmp or --gmp mpir - # The mpir build no longer works because the download fails. - USE_GMP="$2" - if [[ "$USE_GMP" != "gmp" && "$USE_GMP" != "mpir" ]]; then - echo "--gmp option should be gmp or mpir" - exit 1 - fi - shift - shift - ;; - --arb) - # With flint >= 3.0.0 Arb is included so we do not need to build it - # separately. Pass --arb if building for older versions of flint. - BUILD_ARB=yes - shift - ;; - --skip-gmp) - # If you already have a local install of GMP you can pass --skip-gmp - # to skip building it. - SKIP_GMP=yes - shift - ;; - --skip-mpfr) - # If you already have a local install of MPFR you can pass --skip-mpfr - # to skip building it. - SKIP_MPFR=yes - shift - ;; - --patch-gmp-arm64) - # Needed only for GMP 6.2.1 on OSX arm64 (Apple M1) hardware - # As of GMP 6.3.0 this patch is no longer needed - PATCH_GMP_ARM64=yes - shift - ;; - --patch-C23) - # Patch GMP 6.3.0 for newer gcc versions - PATCH_GMP_C23=yes - shift - ;; - --use-gmp-github-mirror) - USE_GMP_GITHUB_MIRROR=yes - shift - ;; - *) - 2>&1 echo "unrecognised argument:" $key - exit 1 - ;; - esac -done - -# ------------------------------------------------------------------------- # -# # -# The build_variables.sh script sets variables specifying the versions to # -# use for all dependencies and also the PREFIX variable. # -# # -# ------------------------------------------------------------------------- # - -source bin/build_variables.sh - -cd $PREFIX -mkdir -p src -cd src - -# ------------------------------------------------------------------------- # -# # -# Now build all dependencies. # -# # -# ------------------------------------------------------------------------- # - -if [ $USE_GMP = "gmp" ]; then - - # ----------------------------------------------------------------------- # - # # - # GMP # - # # - # ----------------------------------------------------------------------- # - - if [ $SKIP_GMP = "yes" ]; then - echo - echo -------------------------------------------- - echo " skipping GMP" - echo -------------------------------------------- - echo - else - echo - echo -------------------------------------------- - echo " building GMP" - echo -------------------------------------------- - echo - - if [ $USE_GMP_GITHUB_MIRROR = "yes" ]; then - # Needed in GitHub Actions because it is blocked from gmplib.org - git clone https://github.com/oscarbenjamin/gmp_mirror.git - cp gmp_mirror/gmp-$GMPVER.tar.xz . - else - curl -O https://gmplib.org/download/gmp/gmp-$GMPVER.tar.xz - fi - - tar xf gmp-$GMPVER.tar.xz - cd gmp-$GMPVER - - # - # See https://github.com/aleaxit/gmpy/issues/350 - # - # We need to patch GMP for OSX arm64 (Apple M1) hardware. This patch is - # from the GMP repo but was applied after the release of GMP 6.2.1. - # This patch is no longer needed for GMP 6.3.0. - # - if [ $PATCH_GMP_ARM64 = "yes" ]; then - echo - echo -------------------------------------------- - echo " patching GMP" - echo -------------------------------------------- - patch -N -Z -p0 < ../../../bin/patch-arm64.diff - fi - # - # https://github.com/msys2/MSYS2-packages/issues/5499 - # - # This patch needed for GMP 6.3.0 building with msys2 or probably just - # newer gcc versions. - # - if [ $PATCH_GMP_C23 = "yes" ]; then - echo - echo -------------------------------------------- - echo " patching GMP" - echo -------------------------------------------- - patch -N -Z < ../../../bin/patch-C23.diff - autoreconf -fi - fi - - # Show the output of configfsf.guess - chmod +x configfsf.guess - ./configfsf.guess - - ./configure --prefix=$PREFIX\ - --enable-fat\ - --enable-shared=yes\ - --enable-static=no\ - --host=$HOST_ARG - make -j6 - make install - - cd .. - - fi - - FLINTARB_WITHGMP="--with-gmp=$PREFIX" - -else - - # ----------------------------------------------------------------------- # - # # - # YASM (needed to build MPIR) # - # # - # ----------------------------------------------------------------------- # - - curl -O http://www.tortall.net/projects/yasm/releases/yasm-$YASMVER.tar.gz - tar xf yasm-$YASMVER.tar.gz - cd yasm-$YASMVER - ./configure --prefix=$PREFIX - make -j6 - make install - cd .. - - # ----------------------------------------------------------------------- # - # # - # MPIR # - # # - # ----------------------------------------------------------------------- # - - # - # The mpir.org domain has expired and no longer hosts the source code so the - # call to curl below will fail. - # We could try to download from https://github.com/wbhart/mpir/releases. - # - # Ultimately it seems that MPIR is no longer maintained though so for now - # this remains unfixed. - # - - >&2 echo "MPIR build of python_flint is no longer supported" - exit 1 - - curl -O http://mpir.org/mpir-$MPIRVER.tar.bz2 - tar xf mpir-$MPIRVER.tar.bz2 - cd mpir-$MPIRVER - ./configure --prefix=$PREFIX\ - --with-yasm=$PREFIX/bin/yasm\ - --enable-fat\ - --enable-shared=yes\ - --enable-static=no\ - --enable-gmpcompat - make -j6 - make install - cd .. - - FLINTARB_WITHGMP="--with-mpir=$PREFIX" - -fi - -# ------------------------------------------------------------------------- # -# # -# MPFR # -# # -# ------------------------------------------------------------------------- # - -if [ $SKIP_MPFR = "yes" ]; then - echo - echo -------------------------------------------- - echo " skipping MPFR" - echo -------------------------------------------- - echo -else - echo - echo -------------------------------------------- - echo " building MPFR" - echo -------------------------------------------- - echo - - if [ $USE_GMP_GITHUB_MIRROR = "yes" ]; then - if [ ! -d "gmp_mirror" ] ; then - git clone https://github.com/oscarbenjamin/gmp_mirror.git - fi - cp gmp_mirror/mpfr-$MPFRVER.tar.gz . - else - curl -O https://ftp.gnu.org/gnu/mpfr/mpfr-$MPFRVER.tar.gz - fi - - tar xf mpfr-$MPFRVER.tar.gz - cd mpfr-$MPFRVER - ./configure --prefix=$PREFIX\ - --host=$HOST_ARG\ - --with-gmp=$PREFIX\ - --enable-shared=yes\ - --enable-static=no - make -j6 - make install - cd .. -fi - -# ------------------------------------------------------------------------- # -# # -# FLINT # -# # -# ------------------------------------------------------------------------- # - -echo -echo -------------------------------------------- -echo " building Flint" -echo -------------------------------------------- -echo - -curl -O -L https://github.com/flintlib/flint/releases/download/v$FLINTVER/flint-$FLINTVER.tar.gz -tar xf flint-$FLINTVER.tar.gz -cd flint-$FLINTVER - ./bootstrap.sh - ./configure --prefix=$PREFIX\ - --host=$HOST_ARG\ - $FLINTARB_WITHGMP\ - --with-mpfr=$PREFIX\ - --disable-static\ - --disable-debug - make -j6 - make install -cd .. - -# ------------------------------------------------------------------------- # -# # -# ARB # -# # -# ------------------------------------------------------------------------- # - -if [ $BUILD_ARB = "yes" ]; then - - echo - echo -------------------------------------------- - echo " building Arb" - echo -------------------------------------------- - echo - - curl -O -L https://github.com/fredrik-johansson/arb/archive/refs/tags/$ARBVER.tar.gz - mv $ARBVER.tar.gz arb-$ARBVER.tar.gz - tar xf arb-$ARBVER.tar.gz - cd arb-$ARBVER - ./configure --prefix=$PREFIX\ - --with-flint=$PREFIX\ - $FLINTARB_WITHGMP\ - --with-mpfr=$PREFIX\ - --disable-static - make -j6 - make install - # - # Set PATH so that DLLs are picked up on Windows. - # - PATH=$PATH:$PREFIX/lib:$PREFIX/bin \ - ARB_TEST_MULTIPLIER=0.1 \ - # Skip Arb tests now because they are slow. - # make check - cd .. -fi - -# ------------------------------------------------------------------------- # -# # -# Done! # -# # -# ------------------------------------------------------------------------- # - -echo -echo ----------------------------------------------------------------------- -echo -echo Build dependencies for python-flint compiled as shared libraries in: -echo $PREFIX -echo -echo Versions: - -if [ $SKIP_GMP = "yes" ]; then - echo GMP: skipped -else - if [[ $USE_GMP = "gmp" ]]; then - echo GMP: $GMPVER - else - echo MPIR: $MPIRVER - fi -fi - -if [ $SKIP_MPFR = "yes" ]; then - echo MPFR: skipped -else - echo MPFR: $MPFRVER -fi - -echo Flint: $FLINTVER - -if [ $BUILD_ARB = "yes" ]; then - echo Arb: $ARBVER -fi -echo -echo ----------------------------------------------------------------------- -echo diff --git a/bin/build_inplace.sh b/bin/build_inplace.sh deleted file mode 100755 index bd208f19..00000000 --- a/bin/build_inplace.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/usr/bin/env bash -# -# Build the flint._flint module in place. - -C_INCLUDE_PATH=.local/include/ LIBRARY_PATH=.local/lib/ python setup.py build_ext --inplace diff --git a/bin/build_variables.sh b/bin/build_variables.sh deleted file mode 100644 index bbed2572..00000000 --- a/bin/build_variables.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/usr/bin/env bash -# -# Create a local directory .local to be used as --prefix when building -# local installs of python-flint's dependencies. This also sets the PREFIX -# shell variable and environment variables giving the versions to use for each -# dependency. This script should be sourced rather than executed e.g.: -# -# $ source bin/build_variables.sh -# -# This is used implicitly by the other build scripts and does not need to be -# executed directly. - -PREFIX=$(pwd)/.local -mkdir -p $PREFIX - -ARBVER=2.23.0 # Not needed with flint >= 3.0.0 (Arb is included in flint) - -YASMVER=1.3.0 # Only needed for MPIR -MPIRVER=3.0.0 # MPIR build no longer works (not clear where to download from) - -# These are the actual dependencies used (at least by default): -GMPVER=6.3.0 -MPFRVER=4.2.2 -FLINTVER='3.3.1' diff --git a/bin/build_wheel.sh b/bin/build_wheel.sh deleted file mode 100755 index e881dda6..00000000 --- a/bin/build_wheel.sh +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env bash -# -# Compile a python-flint wheel using the dependencies built by -# build_dependencies_unix.sh (which should be run first). - -set -o errexit - -source bin/build_variables.sh - -python3 -m venv $PREFIX/venv -source $PREFIX/venv/bin/activate -pip install -U pip -pip install numpy cython wheel - -C_INCLUDE_PATH=.local/include/ LIBRARY_PATH=.local/lib/ pip wheel . diff --git a/bin/bump_version.py b/bin/bump_version.py deleted file mode 100755 index 5d467083..00000000 --- a/bin/bump_version.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env python - -filenames_default = [ - "pyproject.toml", - "src/flint/__init__.py", - "doc/source/conf.py", - "src/flint/test/test_all.py", -] - - -def main(version2=None, *filenames): - """Bump version number in files. - - $ bin/bump_version.py - Current version: 0.1.0 - - $ bin/bump_version.py 0.1.0 0.1.1 - Set version 0.1.0 to 0.1.1 in: - pyproject.toml - src/flint/__init__.py - doc/source/conf.py - src/flint/test/test_all.py - - """ - with open("pyproject.toml", "r") as f: - text = f.read() - version1 = text.split("version = \"")[1].split("\"")[0] - - if not version2: - print(f"Current version: {version1}") - return - - if not filenames: - filenames = filenames_default - - print(f"Set version {version1} to {version2} in:") - for filename in filenames: - print(filename) - with open(filename, "r") as f: - text = f.read() - with open(filename, "w") as f: - f.write(text.replace(version1, version2)) - - -if __name__ == "__main__": - import sys - main(*sys.argv[1:]) diff --git a/bin/cibw.bat b/bin/cibw.bat deleted file mode 100644 index 8f62e8e9..00000000 --- a/bin/cibw.bat +++ /dev/null @@ -1,27 +0,0 @@ -rem -rem This bat file can be used to test cibuildwheel locally on Windows. The -rem cibw_*_windows.sh files have lines to set the PATH for working locally but -rem those are commented out because they are not needed in CI. To use this -rem script -rem -rem 1. Uncomment those lines -rem 2. > pip install cibuildwheel -rem 3. > bin\cibw.bat -rem -rem The variables defined below should match those that are set in CI except -rem that C:\msys64\usr\bin\bash should just be msys2 -c in CI. -rem -rem It is also worth commenting out the line to build GMP etc after you have -rem built those once because that is by far the slowest step. -rem - -rem -rem If this script is run repeatedly then it would fail because of any leftover -rem wheels from a previous run so we delete them here. -rem -del /q wheelhouse\* - -rem override setting in pyproject.toml -set CIBW_BUILD=cp39-* cp310-* cp311-* - -cibuildwheel --platform windows diff --git a/bin/cibw_before_all_linux_aarch64.sh b/bin/cibw_before_all_linux_aarch64.sh deleted file mode 100755 index 3538bef5..00000000 --- a/bin/cibw_before_all_linux_aarch64.sh +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env bash - -set -e - -yum install -y xz -bin/build_dependencies_unix.sh\ - --gmp gmp\ - --host aarch64-pc-linux-gnu\ - --use-gmp-github-mirror diff --git a/bin/cibw_before_all_linux_x86_64.sh b/bin/cibw_before_all_linux_x86_64.sh deleted file mode 100755 index 36d5f844..00000000 --- a/bin/cibw_before_all_linux_x86_64.sh +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env bash - -set -e - -yum install -y xz -bin/build_dependencies_unix.sh\ - --gmp gmp\ - --host x86_64-pc-linux-gnu\ - --use-gmp-github-mirror diff --git a/bin/cibw_before_all_macosx_arm64.sh b/bin/cibw_before_all_macosx_arm64.sh deleted file mode 100755 index 3f98f67a..00000000 --- a/bin/cibw_before_all_macosx_arm64.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/usr/bin/env bash - -set -e - -export CPPFLAGS=" --target=arm64-apple-macos11" -export LDFLAGS=" -arch arm64" - -brew install automake libtool - -bin/build_dependencies_unix.sh\ - --gmp gmp\ - --host aarch64-apple-darwin\ - --use-gmp-github-mirror diff --git a/bin/cibw_before_all_macosx_x86_64.sh b/bin/cibw_before_all_macosx_x86_64.sh deleted file mode 100755 index 15810857..00000000 --- a/bin/cibw_before_all_macosx_x86_64.sh +++ /dev/null @@ -1,10 +0,0 @@ -#!/usr/bin/env bash - -set -e - -brew install automake libtool - -bin/build_dependencies_unix.sh\ - --gmp gmp\ - --host x86_64-apple-darwin\ - --use-gmp-github-mirror diff --git a/bin/cibw_before_all_windows.sh b/bin/cibw_before_all_windows.sh deleted file mode 100755 index a7a359e5..00000000 --- a/bin/cibw_before_all_windows.sh +++ /dev/null @@ -1,20 +0,0 @@ -#!/bin/bash - -set -o errexit - -pacman -S --noconfirm \ - mingw-w64-x86_64-gcc\ - mingw-w64-x86_64-tools-git\ - m4\ - make\ - base-devel\ - autoconf-wrapper\ - automake-wrapper\ - libtool\ - git\ - # - -bin/build_dependencies_unix.sh \ - --use-gmp-github-mirror\ - --patch-C23\ - # diff --git a/bin/cibw_repair_wheel_licenses.py b/bin/cibw_repair_wheel_licenses.py deleted file mode 100755 index de958ea8..00000000 --- a/bin/cibw_repair_wheel_licenses.py +++ /dev/null @@ -1,211 +0,0 @@ -#!/usr/bin/env python -""" -Update license information in wheels after running auditwheel etc. - -Usage: - cibw_repair_wheel_licenses.py \ - --license MIT \ - --license-file ./licenses/license_foo_MIT.txt:foo/LICENSE.txt \ - --license-file ./licenses/license_bar_MIT.txt:bar/LICENSE.txt \ - ... - -The wheel_file argument should be the path to the wheel file to be repaired. -It will be overwritten in place. - -The --license and --license-file arguments are multi-use. The --license -argument should be a SPDX license expression. It will be combined with the -existing License-Expression field in the wheel's METADATA file. - -The --license-file argument should be a pair of :-separated paths. The first -path is the path to the license file and the second is the relative path to -put the license file under the wheel's .dist-info/licenses directory. The first -path can be a glob pattern. The second path can also be a glob pattern in which -case the * is replaced in the same way. This makes it possible to do - - --license-file ./src/foo-*/LICENSE:libs/foo-*/LICENSE - -which would find the LICENSE file src/foo-1.0/LICENSE and copy it to the -matched .dist-info/licenses/libs/foo-1.0/LICENSE path in the wheel. - -PEP 639 says: - -Inside the root license directory, packaging tools MUST reproduce the -directory structure under which the source license files are located -relative to the project root. - -It is not clear what that means though if the licenses are coming from code -that is not vendored in the repo/sdist. If they are vendored then presumably -the argument here should be like: - - --license-file ./vendored-foo/LICENSE:vendored-foo/LICENSE - -""" -import argparse -from pathlib import Path -from subprocess import run -from tempfile import TemporaryDirectory -from shutil import copyfile -from os import makedirs - - -def main(*args: str): - parser = argparse.ArgumentParser() - parser.add_argument("wheel_file") - parser.add_argument("--license", action="append", default=[]) - parser.add_argument("--license-file", action="append", default=[]) - - parsed = parser.parse_args(args) - wheel_file = Path(parsed.wheel_file) - licenses = parsed.license - license_files = dict(arg_to_paths(f) for f in parsed.license_file) - - update_licenses_wheel(wheel_file, licenses, license_files) - - -def arg_to_paths(license_file_arg: str) -> tuple[Path, Path]: - """ - Convert a --license-file argument to a pair of Paths. - """ - paths = license_file_arg.strip().split(":") - if len(paths) != 2: - raise ValueError("license-file argument must be in the form of :" - f" but got {license_file_arg}") - glob1_str, glob2_str = paths - paths1 = list(Path().glob(glob1_str)) - if len(paths1) != 1: - raise ValueError(f"Expected one path from glob pattern {glob1_str}" - f" but got {paths1}") - [path1] = paths1 - - if '*' not in glob2_str: - path2_str = glob2_str - else: - # Replace * in glob2_str with the part of path1 that matches glob1_str: - index1 = glob1_str.index('*') - part1_glob = glob1_str[:index1] - part2_glob = glob1_str[index1+1:] - path1_str = str(path1).replace('\\', '/') - if len(part2_glob) != 0: - wildcard = path1_str[len(part1_glob):-len(part2_glob)] - else: - wildcard = path1_str[len(part1_glob):] - assert path1_str.startswith(part1_glob), ( - f"{path1_str} does not start with {part1_glob}" - ) - assert path1_str.endswith(part2_glob), ( - f"{path1_str} does not end with {part2_glob}" - ) - assert path1_str == part1_glob + wildcard + part2_glob, ( - f"{path1_str} != {part1_glob} + {wildcard} + {part2_glob}" - ) - path2_str = glob2_str.replace('*', wildcard) - - return path1, Path(path2_str) - - -def update_licenses_wheel( - wheel_file: Path, licenses: list[str], license_files: dict[Path, Path] -): - if wheel_file.exists(): - print("Found wheel at", wheel_file) - else: - raise ValueError(f"Wheel not found at {wheel_file}") - - for license_file in license_files: - if license_file.is_absolute(): - raise ValueError("license-file paths must be relative to project root") - elif not license_file.exists(): - raise ValueError(f"license-file not found: {license_file}") - - # foo/bar-1.0-cp310-cp310-linux_x86_64.whl -> bar-1.0 - name, version = wheel_file.stem.split('-')[:2] - base = f"{name}-{version}" - - with TemporaryDirectory() as tmpdir: - - print("temp dir:", tmpdir) - tmpdir = Path(tmpdir) - - run(["wheel", "unpack", "--dest", tmpdir, wheel_file], check=True) - - dist_info = tmpdir / base / f"{base}.dist-info" - - print(f"Adding licenses in {dist_info}") - update_license_dist_info(dist_info, licenses, license_files) - - run(["wheel", "pack", "--dest-dir", tmpdir, tmpdir / base], check=True) - - # glob for *.whl in tmpdir - wheels = list(tmpdir.glob(f"{base}-*.whl")) - if len(wheels) != 1: - raise ValueError(f"Expected one wheel in {tmpdir}, got {wheels}") - new_wheel_file = wheels[0] - - print(f"Repaired wheel: {new_wheel_file}") - print(f"Copying back to: {wheel_file}") - copyfile(new_wheel_file, wheel_file) - - -def update_license_dist_info( - dist_info: Path, licenses: list[str], license_files: dict[Path, Path] -): - for src, dst in license_files.items(): - wheel_license_path = dist_info / "licenses" / dst - if wheel_license_path.exists(): - raise ValueError(f"license file already present: {wheel_license_path}") - # - # PEP 639 says: - # - # Inside the root license directory, packaging tools MUST reproduce the - # directory structure under which the source license files are located - # relative to the project root. - # - makedirs(wheel_license_path.parent, exist_ok=True) - copyfile(src, wheel_license_path) - print(f"Copied license file {src} to {wheel_license_path}") - - metadata_file = dist_info / "METADATA" - - with open(metadata_file, "r") as f: - lines = f.readlines() - - def brackets(s: str) -> str: - if ' ' not in s: - return s - else: - return f"({s})" - - for n, line in enumerate(lines): - if line.startswith("License-Expression: "): - base_license = line[len("License-Expression: ") :].strip() - all_licenses = [base_license, *licenses] - expression = ' AND '.join([brackets(license) for license in all_licenses]) - lines[n] = f"License-Expression: {expression}\n" - break - else: - raise ValueError("Could not find License-Expression in METADATA") - - print("Updated License-Expression from") - print(" " + base_license) - print("to") - print(" " + expression) - - license_files_lines = [line for line in lines if line.startswith("License-File: ")] - - if not license_files_lines: - raise ValueError("Could not find License-File in METADATA") - - index = lines.index(license_files_lines[-1]) + 1 - new_lines = [f"License-File: {f}\n" for f in license_files.values()] - lines = lines[:index] + new_lines + lines[index:] - - print("Writing out METADATA with updated License-Expression and License-File fields") - print("Writing to:", metadata_file) - - with open(metadata_file, "w") as f: - f.writelines(lines) - - -if __name__ == "__main__": - import sys - sys.exit(main(*sys.argv[1:])) diff --git a/bin/coverage.sh b/bin/coverage.sh deleted file mode 100755 index 96058172..00000000 --- a/bin/coverage.sh +++ /dev/null @@ -1,24 +0,0 @@ -#!/bin/bash -# -# Arguments to this script are passed to python -m flint.test e.g. to skip -# doctests and run in quiet mode: -# -# bin/coverage.sh -qt -# -set -o errexit - -RC="--rcfile=.coveragerc.meson" - -# See https://github.com/cython/cython/issues/6658 -# Needed for Python 3.13 only but the plugin does not work with 3.13 anyway... -#pip uninstall -y cython -#pip install git+https://github.com/cython/cython.git@fdbca99 - -pip uninstall -y cython -pip install --pre cython # unpinned to pick up new releases in CI -# pip install cython==3.1.0a1 # known working version for Python < 3.13 - -meson setup build -Dcoverage=true -Dflint_version_check=false -spin run -- coverage run $RC -m flint.test $@ -coverage report $RC -m --sort=cover -coverage html $RC diff --git a/bin/coverage_setuptools.sh b/bin/coverage_setuptools.sh deleted file mode 100755 index dd0cd786..00000000 --- a/bin/coverage_setuptools.sh +++ /dev/null @@ -1,19 +0,0 @@ -#!/bin/bash - -set -e - -RC="--rcfile=.coveragerc.setuptools" - -# Comment out various lines below for speed if running multiple times. - -# See https://github.com/cython/cython/issues/6658 -# Needed for Python 3.13 only -pip uninstall -y cython -pip install git+https://github.com/cython/cython.git@fdbca99 -pip install setuptools - -touch src/*/*/*.pyx -PYTHON_FLINT_COVERAGE=1 python setup.py build_ext --inplace -PYTHONPATH=src coverage run $RC -m flint.test -coverage report $RC -m --sort=cover -coverage html $RC diff --git a/bin/install_flint_ubuntu.sh b/bin/install_flint_ubuntu.sh deleted file mode 100755 index e06b0d8c..00000000 --- a/bin/install_flint_ubuntu.sh +++ /dev/null @@ -1,52 +0,0 @@ -#!/bin/bash - -set -o errexit - -# -# This script should work to build and install Flint from git on Ubuntu -# -# $ git clone https://github.com/flintlib/python-flint.git -# $ cd python-flint -# $ bin/install_flint_ubuntu.sh v3.1.0 -# -# The version is a tag or branch in the Flint repository. -# -# Then to install an sdist from PyPI, use -# -# $ pip install python-flint -# -# To install python-flint from the git checkout -# -# $ pip install . -# - -echo "Building from git: $1" -GIT_REF=$1 - -# Install runtime and build dependencies - -# First install their dependencies and build dependencies -sudo apt-get update -sudo apt-get install libgmp-dev libmpfr-dev xz-utils ninja-build - -# -# This will default to installing in /usr/local. If you want to install in a -# non-standard location then configure flint with -# ./configure --disable-static --prefix=$PREFIX -# If $PREFIX is not in default search paths, then at build time set -# export C_INCLUDE_PATH=$PREFIX/include -# and at runtime set -# export LD_LIBRARY_PATH=$PREFIX/lib -# -echo "Installing Flint from git: $GIT_REF" -git clone https://github.com/flintlib/flint.git -cd flint - git checkout $GIT_REF - ./bootstrap.sh - ./configure --disable-static - make -j - sudo make install -cd .. - -ls -l /usr/local/lib -sudo ldconfig /usr/local/lib diff --git a/bin/install_latest_flint_ubuntu.sh b/bin/install_latest_flint_ubuntu.sh deleted file mode 100755 index 0006b792..00000000 --- a/bin/install_latest_flint_ubuntu.sh +++ /dev/null @@ -1,15 +0,0 @@ -#!/usr/bin/env bash - -set -e - -source bin/build_variables.sh - -sudo apt-get update -sudo apt-get install libgmp-dev libmpfr-dev xz-utils ninja-build - -curl -O -L https://github.com/flintlib/flint/releases/download/v$FLINTVER/flint-$FLINTVER.tar.gz -tar -xzf flint-$FLINTVER.tar.gz -cd flint-$FLINTVER && ./configure --disable-static && make -j$(expr $(nproc) + 1) && sudo make install - -ls -l /usr/local/lib -sudo ldconfig /usr/local/lib diff --git a/bin/patch-C23.diff b/bin/patch-C23.diff deleted file mode 100644 index 5f1c0214..00000000 --- a/bin/patch-C23.diff +++ /dev/null @@ -1,21 +0,0 @@ -# HG changeset patch -# User Marc Glisse -# Date 1738186682 -3600 -# Node ID 8e7bb4ae7a18b1405ea7f9cbcda450b7d920a901 -# Parent e84c5c785bbe8ed8c3620194e50b65adfc2f5d83 -Complete function prototype in acinclude.m4 for C23 compatibility - -diff -r e84c5c785bbe -r 8e7bb4ae7a18 acinclude.m4 ---- a/acinclude.m4 Wed Dec 04 18:26:27 2024 +0100 -+++ b/acinclude.m4 Wed Jan 29 22:38:02 2025 +0100 -@@ -609,7 +609,7 @@ - - #if defined (__GNUC__) && ! defined (__cplusplus) - typedef unsigned long long t1;typedef t1*t2; --void g(){} -+void g(int,t1 const*,t1,t2,t1 const*,int){} - void h(){} - static __inline__ t1 e(t2 rp,t2 up,int n,t1 v0) - {t1 c,x,r;int i;if(v0){c=1;for(i=1;i -# Date 1606685500 -3600 -# Node ID 5f32dbc41afc1f8cd77af1614f0caeb24deb7d7b -# Parent 94c84d919f83ba963ed1809f8e80c7bef32db55c -Avoid the x18 register since it is reserved on Darwin. - -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/aors_n.asm ---- mpn/arm64/aors_n.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/aors_n.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -68,7 +68,7 @@ - EPILOGUE() - PROLOGUE(func_n) - CLRCY --L(ent): lsr x18, n, #2 -+L(ent): lsr x17, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x7, [up] -@@ -77,7 +77,7 @@ - str x13, [rp],#8 - tbnz n, #1, L(b11) - --L(b01): cbz x18, L(ret) -+L(b01): cbz x17, L(ret) - ldp x4, x5, [up,#8] - ldp x8, x9, [vp,#8] - sub up, up, #8 -@@ -88,7 +88,7 @@ - ldp x10, x11, [vp,#8] - add up, up, #8 - add vp, vp, #8 -- cbz x18, L(end) -+ cbz x17, L(end) - b L(top) - - L(bx0): tbnz n, #1, L(b10) -@@ -101,7 +101,7 @@ - - L(b10): ldp x6, x7, [up] - ldp x10, x11, [vp] -- cbz x18, L(end) -+ cbz x17, L(end) - - ALIGN(16) - L(top): ldp x4, x5, [up,#16] -@@ -114,8 +114,8 @@ - ADDSUBC x12, x4, x8 - ADDSUBC x13, x5, x9 - stp x12, x13, [rp],#16 -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x17, x17, #1 -+ cbnz x17, L(top) - - L(end): ADDSUBC x12, x6, x10 - ADDSUBC x13, x7, x11 -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/aorsmul_1.asm ---- mpn/arm64/aorsmul_1.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/aorsmul_1.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -32,10 +32,15 @@ - - include(`../config.m4') - --C cycles/limb --C Cortex-A53 9.3-9.8 --C Cortex-A57 7.0 --C X-Gene 5.0 -+C addmul_1 submul_1 -+C cycles/limb cycles/limb -+C Cortex-A53 9.3-9.8 9.3-9.8 -+C Cortex-A55 9.0-9.5 9.3-9.8 -+C Cortex-A57 7 7 -+C Cortex-A72 -+C Cortex-A73 6 6 -+C X-Gene 5 5 -+C Apple M1 1.75 1.75 - - C NOTES - C * It is possible to keep the carry chain alive between the addition blocks -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/aorsorrlshC_n.asm ---- mpn/arm64/aorsorrlshC_n.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/aorsorrlshC_n.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -65,14 +65,14 @@ - - ASM_START() - PROLOGUE(func_n) -- lsr x18, n, #2 -+ lsr x6, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x5, [up] - tbnz n, #1, L(b11) - - L(b01): ldr x11, [vp] -- cbz x18, L(1) -+ cbz x6, L(1) - ldp x8, x9, [vp,#8] - lsl x13, x11, #LSH - ADDSUB( x15, x13, x5) -@@ -94,7 +94,7 @@ - ADDSUB( x17, x13, x5) - str x17, [rp],#8 - sub up, up, #8 -- cbz x18, L(end) -+ cbz x6, L(end) - b L(top) - - L(bx0): tbnz n, #1, L(b10) -@@ -107,7 +107,7 @@ - L(b10): CLRRCY( x9) - ldp x10, x11, [vp] - sub up, up, #16 -- cbz x18, L(end) -+ cbz x6, L(end) - - ALIGN(16) - L(top): ldp x4, x5, [up,#16] -@@ -124,8 +124,8 @@ - ADDSUBC(x16, x12, x4) - ADDSUBC(x17, x13, x5) - stp x16, x17, [rp],#16 -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x6, x6, #1 -+ cbnz x6, L(top) - - L(end): ldp x4, x5, [up,#16] - extr x12, x10, x9, #RSH -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/cnd_aors_n.asm ---- mpn/arm64/cnd_aors_n.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/cnd_aors_n.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -65,7 +65,7 @@ - - CLRCY - -- lsr x18, n, #2 -+ lsr x17, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x13, [vp] -@@ -75,7 +75,7 @@ - str x9, [rp] - tbnz n, #1, L(b11) - --L(b01): cbz x18, L(rt) -+L(b01): cbz x17, L(rt) - ldp x12, x13, [vp,#8] - ldp x10, x11, [up,#8] - sub up, up, #8 -@@ -86,7 +86,7 @@ - L(b11): ldp x12, x13, [vp,#8]! - ldp x10, x11, [up,#8]! - sub rp, rp, #8 -- cbz x18, L(end) -+ cbz x17, L(end) - b L(top) - - L(bx0): ldp x12, x13, [vp] -@@ -99,7 +99,7 @@ - b L(mid) - - L(b10): sub rp, rp, #16 -- cbz x18, L(end) -+ cbz x17, L(end) - - ALIGN(16) - L(top): bic x6, x12, cnd -@@ -116,8 +116,8 @@ - ADDSUBC x9, x11, x7 - ldp x10, x11, [up,#32]! - stp x8, x9, [rp,#32]! -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x17, x17, #1 -+ cbnz x17, L(top) - - L(end): bic x6, x12, cnd - bic x7, x13, cnd -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/logops_n.asm ---- mpn/arm64/logops_n.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/logops_n.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -78,7 +78,7 @@ - - ASM_START() - PROLOGUE(func) -- lsr x18, n, #2 -+ lsr x17, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x7, [up] -@@ -88,7 +88,7 @@ - str x15, [rp],#8 - tbnz n, #1, L(b11) - --L(b01): cbz x18, L(ret) -+L(b01): cbz x17, L(ret) - ldp x4, x5, [up,#8] - ldp x8, x9, [vp,#8] - sub up, up, #8 -@@ -99,7 +99,7 @@ - ldp x10, x11, [vp,#8] - add up, up, #8 - add vp, vp, #8 -- cbz x18, L(end) -+ cbz x17, L(end) - b L(top) - - L(bx0): tbnz n, #1, L(b10) -@@ -110,7 +110,7 @@ - - L(b10): ldp x6, x7, [up] - ldp x10, x11, [vp] -- cbz x18, L(end) -+ cbz x17, L(end) - - ALIGN(16) - L(top): ldp x4, x5, [up,#16] -@@ -127,8 +127,8 @@ - POSTOP( x12) - POSTOP( x13) - stp x12, x13, [rp],#16 -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x17, x17, #1 -+ cbnz x17, L(top) - - L(end): LOGOP( x12, x6, x10) - LOGOP( x13, x7, x11) -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/lshift.asm ---- mpn/arm64/lshift.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/lshift.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -61,7 +61,7 @@ - add rp, rp_arg, n, lsl #3 - add up, up, n, lsl #3 - sub tnc, xzr, cnt -- lsr x18, n, #2 -+ lsr x17, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x4, [up,#-8] -@@ -69,7 +69,7 @@ - - L(b01): NSHIFT x0, x4, tnc - PSHIFT x2, x4, cnt -- cbnz x18, L(gt1) -+ cbnz x17, L(gt1) - str x2, [rp,#-8] - ret - L(gt1): ldp x4, x5, [up,#-24] -@@ -89,7 +89,7 @@ - PSHIFT x13, x5, cnt - NSHIFT x10, x4, tnc - PSHIFT x2, x4, cnt -- cbnz x18, L(gt2) -+ cbnz x17, L(gt2) - orr x10, x10, x13 - stp x2, x10, [rp,#-16] - ret -@@ -123,11 +123,11 @@ - orr x11, x12, x2 - stp x10, x11, [rp,#-32]! - PSHIFT x2, x4, cnt --L(lo0): sub x18, x18, #1 -+L(lo0): sub x17, x17, #1 - L(lo3): NSHIFT x10, x6, tnc - PSHIFT x13, x7, cnt - NSHIFT x12, x7, tnc -- cbnz x18, L(top) -+ cbnz x17, L(top) - - L(end): orr x10, x10, x13 - orr x11, x12, x2 -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/lshiftc.asm ---- mpn/arm64/lshiftc.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/lshiftc.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -61,7 +61,7 @@ - add rp, rp_arg, n, lsl #3 - add up, up, n, lsl #3 - sub tnc, xzr, cnt -- lsr x18, n, #2 -+ lsr x17, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x4, [up,#-8] -@@ -69,7 +69,7 @@ - - L(b01): NSHIFT x0, x4, tnc - PSHIFT x2, x4, cnt -- cbnz x18, L(gt1) -+ cbnz x17, L(gt1) - mvn x2, x2 - str x2, [rp,#-8] - ret -@@ -90,7 +90,7 @@ - PSHIFT x13, x5, cnt - NSHIFT x10, x4, tnc - PSHIFT x2, x4, cnt -- cbnz x18, L(gt2) -+ cbnz x17, L(gt2) - eon x10, x10, x13 - mvn x2, x2 - stp x2, x10, [rp,#-16] -@@ -125,11 +125,11 @@ - eon x11, x12, x2 - stp x10, x11, [rp,#-32]! - PSHIFT x2, x4, cnt --L(lo0): sub x18, x18, #1 -+L(lo0): sub x17, x17, #1 - L(lo3): NSHIFT x10, x6, tnc - PSHIFT x13, x7, cnt - NSHIFT x12, x7, tnc -- cbnz x18, L(top) -+ cbnz x17, L(top) - - L(end): eon x10, x10, x13 - eon x11, x12, x2 -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/mul_1.asm ---- mpn/arm64/mul_1.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/mul_1.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -56,7 +56,7 @@ - - PROLOGUE(mpn_mul_1) - adds x4, xzr, xzr C clear register and cy flag --L(com): lsr x18, n, #2 -+L(com): lsr x17, n, #2 - tbnz n, #0, L(bx1) - - L(bx0): mov x11, x4 -@@ -65,7 +65,7 @@ - L(b10): ldp x4, x5, [up] - mul x8, x4, v0 - umulh x10, x4, v0 -- cbz x18, L(2) -+ cbz x17, L(2) - ldp x6, x7, [up,#16]! - mul x9, x5, v0 - b L(mid)-8 -@@ -80,7 +80,7 @@ - str x9, [rp],#8 - tbnz n, #1, L(b10) - --L(b01): cbz x18, L(1) -+L(b01): cbz x17, L(1) - - L(b00): ldp x6, x7, [up] - mul x8, x6, v0 -@@ -90,8 +90,8 @@ - adcs x12, x8, x11 - umulh x11, x7, v0 - add rp, rp, #16 -- sub x18, x18, #1 -- cbz x18, L(end) -+ sub x17, x17, #1 -+ cbz x17, L(end) - - ALIGN(16) - L(top): mul x8, x4, v0 -@@ -110,8 +110,8 @@ - stp x12, x13, [rp],#32 - adcs x12, x8, x11 - umulh x11, x7, v0 -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x17, x17, #1 -+ cbnz x17, L(top) - - L(end): mul x8, x4, v0 - adcs x13, x9, x10 -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/rsh1aors_n.asm ---- mpn/arm64/rsh1aors_n.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/rsh1aors_n.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -59,7 +59,7 @@ - - ASM_START() - PROLOGUE(func_n) -- lsr x18, n, #2 -+ lsr x6, n, #2 - - tbz n, #0, L(bx0) - -@@ -69,7 +69,7 @@ - - L(b01): ADDSUB x13, x5, x9 - and x10, x13, #1 -- cbz x18, L(1) -+ cbz x6, L(1) - ldp x4, x5, [up],#48 - ldp x8, x9, [vp],#48 - ADDSUBC x14, x4, x8 -@@ -80,8 +80,8 @@ - ADDSUBC x12, x4, x8 - ADDSUBC x13, x5, x9 - str x17, [rp], #24 -- sub x18, x18, #1 -- cbz x18, L(end) -+ sub x6, x6, #1 -+ cbz x6, L(end) - b L(top) - - L(1): cset x14, COND -@@ -97,7 +97,7 @@ - ldp x8, x9, [vp],#32 - ADDSUBC x12, x4, x8 - ADDSUBC x13, x5, x9 -- cbz x18, L(3) -+ cbz x6, L(3) - ldp x4, x5, [up,#-16] - ldp x8, x9, [vp,#-16] - extr x17, x12, x15, #1 -@@ -117,7 +117,7 @@ - ADDSUB x12, x4, x8 - ADDSUBC x13, x5, x9 - and x10, x12, #1 -- cbz x18, L(2) -+ cbz x6, L(2) - ldp x4, x5, [up,#-16] - ldp x8, x9, [vp,#-16] - ADDSUBC x14, x4, x8 -@@ -134,8 +134,8 @@ - ADDSUBC x12, x4, x8 - ADDSUBC x13, x5, x9 - add rp, rp, #16 -- sub x18, x18, #1 -- cbz x18, L(end) -+ sub x6, x6, #1 -+ cbz x6, L(end) - - ALIGN(16) - L(top): ldp x4, x5, [up,#-16] -@@ -152,8 +152,8 @@ - ADDSUBC x12, x4, x8 - ADDSUBC x13, x5, x9 - stp x16, x17, [rp],#32 -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x6, x6, #1 -+ cbnz x6, L(top) - - L(end): extr x16, x15, x14, #1 - extr x17, x12, x15, #1 -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/rshift.asm ---- mpn/arm64/rshift.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/rshift.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -60,7 +60,7 @@ - PROLOGUE(mpn_rshift) - mov rp, rp_arg - sub tnc, xzr, cnt -- lsr x18, n, #2 -+ lsr x17, n, #2 - tbz n, #0, L(bx0) - - L(bx1): ldr x5, [up] -@@ -68,7 +68,7 @@ - - L(b01): NSHIFT x0, x5, tnc - PSHIFT x2, x5, cnt -- cbnz x18, L(gt1) -+ cbnz x17, L(gt1) - str x2, [rp] - ret - L(gt1): ldp x4, x5, [up,#8] -@@ -89,7 +89,7 @@ - PSHIFT x13, x4, cnt - NSHIFT x10, x5, tnc - PSHIFT x2, x5, cnt -- cbnz x18, L(gt2) -+ cbnz x17, L(gt2) - orr x10, x10, x13 - stp x10, x2, [rp] - ret -@@ -121,11 +121,11 @@ - orr x11, x12, x2 - stp x11, x10, [rp,#32]! - PSHIFT x2, x5, cnt --L(lo0): sub x18, x18, #1 -+L(lo0): sub x17, x17, #1 - L(lo3): NSHIFT x10, x7, tnc - NSHIFT x12, x6, tnc - PSHIFT x13, x6, cnt -- cbnz x18, L(top) -+ cbnz x17, L(top) - - L(end): orr x10, x10, x13 - orr x11, x12, x2 -diff -r 94c84d919f83 -r 5f32dbc41afc mpn/arm64/sqr_diag_addlsh1.asm ---- mpn/arm64/sqr_diag_addlsh1.asm Sat Nov 28 23:38:32 2020 +0100 -+++ mpn/arm64/sqr_diag_addlsh1.asm Sun Nov 29 22:31:40 2020 +0100 -@@ -47,7 +47,7 @@ - ASM_START() - PROLOGUE(mpn_sqr_diag_addlsh1) - ldr x15, [up],#8 -- lsr x18, n, #1 -+ lsr x14, n, #1 - tbz n, #0, L(bx0) - - L(bx1): adds x7, xzr, xzr -@@ -62,8 +62,8 @@ - ldr x17, [up],#16 - ldp x6, x7, [tp],#32 - umulh x11, x15, x15 -- sub x18, x18, #1 -- cbz x18, L(end) -+ sub x14, x14, #1 -+ cbz x14, L(end) - - ALIGN(16) - L(top): extr x9, x6, x5, #63 -@@ -84,8 +84,8 @@ - extr x8, x5, x4, #63 - stp x12, x13, [rp],#16 - adcs x12, x8, x10 -- sub x18, x18, #1 -- cbnz x18, L(top) -+ sub x14, x14, #1 -+ cbnz x14, L(top) - - L(end): extr x9, x6, x5, #63 - mul x10, x17, x17 diff --git a/bin/pyodide_build_dependencies.sh b/bin/pyodide_build_dependencies.sh deleted file mode 100755 index c33be79f..00000000 --- a/bin/pyodide_build_dependencies.sh +++ /dev/null @@ -1,122 +0,0 @@ -#!/bin/bash - -set -e - -while [[ $# -gt 0 ]] -do - key="$1" - case $key in - -h|--help) - echo "bin/pyodide_build_dependencies.sh [options]" - echo - echo "Build local emscripten installs of python-flint's dependencies." - echo - echo "Supported options:" - echo " --help - show this help message" - echo " --wasm-library-dir - directory to install libraries" - echo " --flint-commit - flint commit to build" - echo - exit - ;; - --wasm-library-dir) - # e.g. --wasm-library-dir /path/to/wasm-library-dir - WASM_LIBRARY_DIR="$2" - shift - shift - ;; - --flint-commit) - # e.g. --flint-commit 3.3.1 - FLINT_COMMIT="$2" - shift - shift - ;; - *) - 2>&1 echo "unrecognised argument:" $key - exit 1 - ;; - esac -done - - -if [ -z "$WASM_LIBRARY_DIR" ]; then - echo "WASM_LIBRARY_DIR not set" - exit 1 -fi - -# Sets versions of GMP, MPFR and FLINT: - -source bin/build_variables.sh - -# Download mirrored copy of source distributions for GMP and MPFR - -git clone https://github.com/oscarbenjamin/gmp_mirror.git -cp gmp_mirror/gmp-$GMPVER.tar.xz . -cp gmp_mirror/mpfr-$MPFRVER.tar.gz . -tar -xf gmp-$GMPVER.tar.xz -tar -xf mpfr-$MPFRVER.tar.gz - - -# ---------------------------Build GMP ----------------------------------# - - -cd gmp-$GMPVER - - emconfigure ./configure \ - --disable-dependency-tracking \ - --host none \ - --disable-shared \ - --enable-static \ - --enable-cxx \ - --prefix=$WASM_LIBRARY_DIR - - emmake make -j $(nproc) - emmake make install - -cd .. - - -# ---------------------------Build MPFR ----------------------------------# - - -cd mpfr-$MPFRVER - - emconfigure ./configure \ - --disable-dependency-tracking \ - --disable-shared \ - --with-gmp=$WASM_LIBRARY_DIR \ - --prefix=$WASM_LIBRARY_DIR - - emmake make -j $(nproc) - emmake make install - -cd .. - - -# ---------------------------Build FLINT----------------------------------# - - -if [ -z "$FLINT_COMMIT" ]; then - curl -O -L https://github.com/flintlib/flint/releases/download/v$FLINTVER/flint-$FLINTVER.tar.gz - tar xf flint-$FLINTVER.tar.gz - cd flint-$FLINTVER -else - git clone https://github.com/flintlib/flint --branch $FLINT_COMMIT - cd flint -fi - - ./bootstrap.sh - - emconfigure ./configure \ - --disable-dependency-tracking \ - --disable-shared \ - --prefix=$WASM_LIBRARY_DIR \ - --with-gmp=$WASM_LIBRARY_DIR \ - --with-mpfr=$WASM_LIBRARY_DIR \ - --host=wasm32-unknown-emscripten \ - --disable-assembly \ - --disable-pthread - - emmake make -j $(nproc) - emmake make install - -cd .. diff --git a/bin/rst_to_pxd.py b/bin/rst_to_pxd.py deleted file mode 100755 index 4320ef4b..00000000 --- a/bin/rst_to_pxd.py +++ /dev/null @@ -1,236 +0,0 @@ -#!/usr/bin/env python3 - -from collections import defaultdict -import re -import sys -import os -import fnmatch -import argparse - -""" -This is relatively rudimentary, but works for the purpose intended - -To use this to parse an arb rst file - -python rst_to_pxd basename - -or to parse a flint rst file - -python rst_to_pxd flint/basename - -the pxd file is dumped to stdout - -for example -python rst_to_pxd flint/fmpz_poly - -will output a skeleton fmpz_poly.pxd to stdout - - -You will need to configure the location of the flintlib submodule directory and the locations of the flint and -arb doc source directories. - -The other useful configuration is the comment_types and set which are two representations of the types that are -not implemented and therefore we want to comment functions that reference them - -TODO: DRY with comment types, also should be able to add commented types from the command line. -TODO: don't import self - -""" - -# recognize a function definition in rst -is_func = re.compile(r"\.\.( )+(c:)?function( )*::") -# rename types to avoid python -- c name collisions -rename_types = [ - (re.compile(r"\bfmpz\b"),"fmpz_struct"), - (re.compile(r"\bfmpq\b"), "fmpq_struct"), - (re.compile(r"\bin\b"), "in_"), - (re.compile(r"\blambda\b"), "lambda_"), -] -# comment out functions which use these types -comment_types = re.compile(r"(\bFILE\b)|(\bmpz_t\b)|(\bmpq_t\b)") -comment_set = set(["FILE", "mpz_t", "mpq_t"]) -c_types = set(["void", "char", "short", "long", "int", "float", "double"]) -type_modifers = re.compile(r"\*|(\bconst\b)|(\bunsigned\b)|(\bsigned\b)") -import_dict = {} -# gr_domains.rst lists functions that are in gr.h -doc_to_header = {'flint/gr_domains': 'flint/gr'} - - - -def get_cython_struct_types(file): - """ - Extract cython types from a pxd file. - """ - ret = [] - for line in file: - l = line.strip() - if l[:8] == "ctypedef": - if l[-1] == ']': - # ctypedef foo foo_t[0] - l = l[:l.rfind('[')] - elif '(' in l: - # ctypedef int (*foo_func)(...) - l = l[l.index('('):].lstrip('(*') - l = l[:l.index(')')] - else: - # ctypedef foo: - l = l.strip(':') - ret.append(l.split()[-1]) - return ret - - -def fill_import_dict(pyflintlibdir): - """ - Get a map from cython structs to the pxd that defines them - """ - import_dict['fmpq_struct'] = 'types.fmpq' - - with os.scandir(pyflintlibdir + '/types') as entry: - for f in entry: - if fnmatch.fnmatch(f.name, "*.pxd"): - with open(f.path) as pxd: - for t in get_cython_struct_types(pxd): - import_dict[t] = 'types.' + f.name.split('.')[0] - - -def undecorate(str): - """ - remove variable name, const, ``*``, etc. to just get types - """ - ret = str.strip() - if ' ' in ret: - ret = ret[:ret.rfind(' ')] - ret = re.sub(type_modifers, '', ret).strip() - return ret - - -def get_parameter_types(str): - params = str[str.find("(") + 1 : str.rfind(")")].split(",") - ret_type = str.split('(')[0].rsplit(' ', 1)[0] - params.append(ret_type) - return [undecorate(s) for s in params if s] - - -def clean_types(function): - ret = function.strip() - for old, new in rename_types: - ret = re.sub(old, new, ret) - return ret - - -def get_functions(file): - """ - Get a list of functions from an rst file - """ - ret = [] - macros = [] - in_list = False - for line in file: - # Keep track of the macros - # We want to give them types in cython... - if line.startswith('.. macro'): - macros.append(line.strip()) - continue - - if line.strip().endswith('\\'): - continue - - m = is_func.match(line) - if m: - ret.append(clean_types(line[m.end():])) - in_list = True - else: - if in_list: - if line.strip() == '': - in_list = False - else: - ret.append(clean_types(line)) - return ret, macros - - -def get_all_types(function_list): - ret = set() - for f in function_list: - for t in get_parameter_types(f): - ret.add(t) - return ret - - -def has_types(line, types): - #ts = set(t for t in get_parameter_types(line) if t in types) - #if ts: - # print(ts, file=sys.stderr) - return any(t in types for t in get_parameter_types(line)) - - -def gen_imports(function_list): - """ - Generate import statements for known functions. - """ - imports = defaultdict(list) - s = get_all_types(function_list) - s = s - c_types - ret = set([]) - for t in s: - if t in import_dict: - imports[import_dict[t]].append(t) - else: - ret.add(t) - for k, v in sorted(imports.items()): - types = ", ".join(sorted(v)) - print("from flint.flintlib." + k + " cimport " + types) - return sorted(ret) - - - - -def generate_pxd_file(h_name, opts): - fill_import_dict(opts.flint_lib_dir) - l = [] - docdir = opts.arb_doc_dir - name = h_name - h_name = doc_to_header.get(h_name, h_name) - - if name[:6] == "flint/": - docdir = opts.flint_doc_dir - name = name[6:] - with open(os.path.join(docdir, name + ".rst")) as f: - l, macros = get_functions(f) - unknown_types = gen_imports(l) - print() - for t in unknown_types: - print("# unknown type " + t) - print() - for m in macros: - print("# " + m) - print() - print(r'cdef extern from "' + h_name + r'.h":') - for f in l: - if has_types(f, unknown_types): - print(" # " + f) - else: - print(" " + f) - - -def main(*args): - usage = """ - $ cd /path/to/python-flint - $ bin/rst_to_pxd.py flint/fmpz --flint-doc-dir=/path/to/flint/doc/source - """ - parser = argparse.ArgumentParser(description='Generate a pxd file from an rst file', - usage=usage) - parser.add_argument('--flint-lib-dir', help='location of the flintlib submodule', - default="./src/flint/flintlib") - parser.add_argument('--arb-doc-dir', help='location of the arb doc source directory', - default="/Users/davideinstein/projects/arb/doc/source") - parser.add_argument('--flint-doc-dir', help='location of the flint doc source directory', - default="/Users/davideinstein/projects/flint2/doc/source") - parser.add_argument('name', help='name of the rst file to parse (e.g. flint/fmpz)') - - args = parser.parse_args() - - generate_pxd_file(args.name, args) - - -if __name__ == "__main__": - main(*sys.argv[1:]) diff --git a/bin/rtd_before_all_linux.sh b/bin/rtd_before_all_linux.sh deleted file mode 100755 index ff4cddba..00000000 --- a/bin/rtd_before_all_linux.sh +++ /dev/null @@ -1,8 +0,0 @@ -#!/usr/bin/env bash - -apt-get install xz-utils - -bin/build_dependencies_unix.sh\ - --gmp gmp\ - --host x86_64-pc-linux-gnu\ - --use-gmp-github-mirror diff --git a/coverage_plugin.py b/coverage_plugin.py deleted file mode 100644 index 8382dc26..00000000 --- a/coverage_plugin.py +++ /dev/null @@ -1,184 +0,0 @@ -""" -A Cython plugin for coverage.py suitable for a spin/meson project. - -This follows the same general approach as Cython's coverage plugin and uses the -Cython plugin for parsing the C files. The difference here is that files are -laid out very differently in a meson project. Assuming meson makes it a lot -easier to find all the C files because we can just parse the build.ninja file. - -https://coverage.readthedocs.io/en/latest/api_plugin.html -https://github.com/cython/cython/blob/master/Cython/Coverage.py -""" -import re -from collections import defaultdict - -from coverage.plugin import CoveragePlugin, FileTracer, FileReporter - -from functools import cache -from pathlib import Path - - -# Paths used by spin/meson in a src-layout: -root_dir = Path(__file__).parent -build_dir = root_dir / 'build' -build_install_dir = root_dir / 'build-install' -src_dir = root_dir / 'src' - - -def get_ninja_build_rules(): - """Read all build rules from build.ninja.""" - rules = [] - with open(build_dir / 'build.ninja') as build_ninja: - for line in build_ninja: - line = line.strip() - if line.startswith('build '): - line = line[len('build '):] - target, rule = line.split(': ') - if target == 'PHONY': - continue - compiler, *srcfiles = rule.split(' ') - # target is a path relative to the build directory. We will - # turn that into an absolute path so that all paths in target - # and srcfiles are absolute. - target = str(build_dir / target) - rule = (target, compiler, srcfiles) - rules.append(rule) - return rules - - -def get_cython_build_rules(): - """Get all Cython build rules.""" - cython_rules = [] - - for target, compiler, srcfiles in get_ninja_build_rules(): - if compiler == 'cython_COMPILER': - assert target.endswith('.c') - assert len(srcfiles) == 1 and srcfiles[0].endswith('.pyx') - c_file = target - [cython_file] = srcfiles - cython_rules.append((c_file, cython_file)) - - return cython_rules - - -@cache -def parse_all_cfile_lines(): - """Parse all generated C files from the build directory.""" - # - # Each .c file can include code generated from multiple Cython files (e.g. - # because of .pxd files) being cimported. Each Cython file can contribute - # to more than one .c file. Here we parse all .c files and then collect - # together all the executable lines from all of the Cython files into a - # dict like this: - # - # {filename: {lineno: linestr, ...}, ...} - # - # This function is cached because it only needs calling once and is - # expensive. - # - all_code_lines = {} - - for c_file, _ in get_cython_build_rules(): - - cfile_lines = parse_cfile_lines(c_file) - - for cython_file, line_map in cfile_lines.items(): - if cython_file == '(tree fragment)': - continue - elif cython_file in all_code_lines: - # Possibly need to merge the lines? - assert all_code_lines[cython_file] == line_map - else: - all_code_lines[cython_file] = line_map - - return all_code_lines - - -def parse_cfile_lines(c_file): - """Use Cython's coverage plugin to parse the C code.""" - from Cython.Coverage import Plugin - return Plugin()._parse_cfile_lines(c_file) - - -class Plugin(CoveragePlugin): - """A coverage plugin for a spin/meson project with Cython code.""" - - def file_tracer(self, filename): - """Find a tracer for filename to handle trace events.""" - path = Path(filename) - - if path.suffix in ('.pyx', '.pxd') and root_dir in path.parents: - # A .pyx file from the src directory. The path has src - # stripped out and is not a real absolute path but it looks - # like one. Remove the root prefix and then we have a path - # relative to src_dir. - srcpath = path.relative_to(root_dir) - return CyFileTracer(srcpath) - else: - # All sorts of paths come here and we reject them - return None - - def file_reporter(self, filename): - """Return a file reporter for filename.""" - srcfile = Path(filename).relative_to(src_dir) - return CyFileReporter(srcfile) - - -class CyFileTracer(FileTracer): - """File tracer for Cython files (.pyx,.pxd).""" - - def __init__(self, srcpath): - assert (src_dir / srcpath).exists() - self.srcpath = srcpath - - def source_filename(self): - return self.srcpath - - def has_dynamic_source_filename(self): - return True - - def dynamic_source_filename(self, filename, frame): - """Get filename from frame and return abspath to file.""" - # What is returned here needs to match CyFileReporter.filename - path = frame.f_code.co_filename - return self.get_source_filename(path) - - # This is called for every traced line. Cache it: - @staticmethod - @cache - def get_source_filename(filename): - """Get src-relative path for filename from trace event.""" - path = src_dir / filename - assert src_dir in path.parents - assert path.exists() - return str(path) - - -class CyFileReporter(FileReporter): - """File reporter for Cython or Python files (.pyx,.pxd,.py).""" - - def __init__(self, srcpath): - abspath = (src_dir / srcpath) - assert abspath.exists() - - # filepath here needs to match dynamic_source_filename - super().__init__(str(abspath)) - - self.srcpath = srcpath - - def relative_filename(self): - """Path displayed in the coverage reports.""" - return str(self.srcpath) - - def lines(self): - """Set of line numbers for possibly traceable lines.""" - srcpath = str(self.srcpath) - all_line_maps = parse_all_cfile_lines() - line_map = all_line_maps[srcpath] - return set(line_map) - - -def coverage_init(reg, options): - plugin = Plugin() - reg.add_configurer(plugin) - reg.add_file_tracer(plugin) diff --git a/doc/Makefile b/doc/Makefile deleted file mode 100644 index d8fdc1ba..00000000 --- a/doc/Makefile +++ /dev/null @@ -1,153 +0,0 @@ -# Makefile for Sphinx documentation -# - -# You can set these variables from the command line. -SPHINXOPTS = -SPHINXBUILD = sphinx-build -PAPER = -BUILDDIR = build - -# Internal variables. -PAPEROPT_a4 = -D latex_paper_size=a4 -PAPEROPT_letter = -D latex_paper_size=letter -ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source -# the i18n builder cannot share the environment and doctrees with the others -I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source - -.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext - -help: - @echo "Please use \`make ' where is one of" - @echo " html to make standalone HTML files" - @echo " dirhtml to make HTML files named index.html in directories" - @echo " singlehtml to make a single large HTML file" - @echo " pickle to make pickle files" - @echo " json to make JSON files" - @echo " htmlhelp to make HTML files and a HTML help project" - @echo " qthelp to make HTML files and a qthelp project" - @echo " devhelp to make HTML files and a Devhelp project" - @echo " epub to make an epub" - @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" - @echo " latexpdf to make LaTeX files and run them through pdflatex" - @echo " text to make text files" - @echo " man to make manual pages" - @echo " texinfo to make Texinfo files" - @echo " info to make Texinfo files and run them through makeinfo" - @echo " gettext to make PO message catalogs" - @echo " changes to make an overview of all changed/added/deprecated items" - @echo " linkcheck to check all external links for integrity" - @echo " doctest to run all doctests embedded in the documentation (if enabled)" - -clean: - -rm -rf $(BUILDDIR)/* - -html: - $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html - @echo - @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." - -dirhtml: - $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml - @echo - @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." - -singlehtml: - $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml - @echo - @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." - -pickle: - $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle - @echo - @echo "Build finished; now you can process the pickle files." - -json: - $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json - @echo - @echo "Build finished; now you can process the JSON files." - -htmlhelp: - $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp - @echo - @echo "Build finished; now you can run HTML Help Workshop with the" \ - ".hhp project file in $(BUILDDIR)/htmlhelp." - -qthelp: - $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp - @echo - @echo "Build finished; now you can run "qcollectiongenerator" with the" \ - ".qhcp project file in $(BUILDDIR)/qthelp, like this:" - @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/python-flint.qhcp" - @echo "To view the help file:" - @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/python-flint.qhc" - -devhelp: - $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp - @echo - @echo "Build finished." - @echo "To view the help file:" - @echo "# mkdir -p $$HOME/.local/share/devhelp/python-flint" - @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/python-flint" - @echo "# devhelp" - -epub: - $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub - @echo - @echo "Build finished. The epub file is in $(BUILDDIR)/epub." - -latex: - $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex - @echo - @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." - @echo "Run \`make' in that directory to run these through (pdf)latex" \ - "(use \`make latexpdf' here to do that automatically)." - -latexpdf: - $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex - @echo "Running LaTeX files through pdflatex..." - $(MAKE) -C $(BUILDDIR)/latex all-pdf - @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." - -text: - $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text - @echo - @echo "Build finished. The text files are in $(BUILDDIR)/text." - -man: - $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man - @echo - @echo "Build finished. The manual pages are in $(BUILDDIR)/man." - -texinfo: - $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo - @echo - @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." - @echo "Run \`make' in that directory to run these through makeinfo" \ - "(use \`make info' here to do that automatically)." - -info: - $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo - @echo "Running Texinfo files through makeinfo..." - make -C $(BUILDDIR)/texinfo info - @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." - -gettext: - $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale - @echo - @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." - -changes: - $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes - @echo - @echo "The overview file is in $(BUILDDIR)/changes." - -linkcheck: - $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck - @echo - @echo "Link check complete; look for any errors in the above output " \ - "or in $(BUILDDIR)/linkcheck/output.txt." - -doctest: - $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest - @echo "Testing of doctests in the sources finished, look at the " \ - "results in $(BUILDDIR)/doctest/output.txt." diff --git a/doc/build/doctrees/environment.pickle b/doc/build/doctrees/environment.pickle new file mode 100644 index 00000000..5df1dd88 Binary files /dev/null and b/doc/build/doctrees/environment.pickle differ diff --git a/doc/build/doctrees/index.doctree b/doc/build/doctrees/index.doctree new file mode 100644 index 00000000..1311eedc Binary files /dev/null and b/doc/build/doctrees/index.doctree differ diff --git a/doc/build/html/.buildinfo b/doc/build/html/.buildinfo new file mode 100644 index 00000000..6f92e859 --- /dev/null +++ b/doc/build/html/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. +config: b514d003e6274a2ea15305cbb779ea19 +tags: fbb0d17656682115ca4d033fb2f83ba1 diff --git a/doc/build/html/_modules/index.html b/doc/build/html/_modules/index.html new file mode 100644 index 00000000..a8ec0320 --- /dev/null +++ b/doc/build/html/_modules/index.html @@ -0,0 +1,87 @@ + + + + + + + + + + Overview: module code — python-flint 0.1 documentation + + + + + + + + + + + + +
+

Navigation

+ +
+ +
+
+
+
+ +

All modules for which code is available

+ + +
+
+
+
+
+ + +
+
+
+
+
+

Navigation

+ +
+
+ © Copyright 2012, Fredrik Johansson. + Created using Sphinx 1.1.3. +
+ + \ No newline at end of file diff --git a/doc/build/html/_sources/index.txt b/doc/build/html/_sources/index.txt new file mode 100644 index 00000000..9e7b722b --- /dev/null +++ b/doc/build/html/_sources/index.txt @@ -0,0 +1,138 @@ +.. python-flint documentation master file, created by + sphinx-quickstart on Wed Jul 18 11:49:46 2012. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Python bindings for FLINT +========================================================== + +Introduction +:::::::::::: + +The python-flint Python extension module provides +bindings to FLINT (http://flintlib.org/). +FLINT (Fast Library for Number Theory) is a C library that implements +highly optimised exact scalar, polynomial and matrix arithmetic as +well as many number-theoretic special functions. + +As of the current version, only a subset of the FLINT types +are wrapped, and only a very limited selection of methods are provided. +There are known and unknown bugs, and the interface is subject to +change drastically in the future. Any feedback is welcome +and can be sent to fredrik.johansson@gmail.com or flint-devel@googlegroups.com. +Of particular note: + +* Most functionality in FLINT is not yet wrapped! +* Coercions are not supported in all directions. +* Conversion between Python longs and fmpzs is not done efficiently. +* Types don't yet provide hash methods. +* Interaction with gmpy (http://gmpy.org/) types (and types from many other libraries) is not supported. + +Setup +:::::::::::: + +To build this module, you first need to install the latest +version of FLINT (follow the instructions in the FLINT documentation). You +also need to install Cython (http://cython.org/). + +Next, extract the python-flint archive and run:: + + python ./setup.py build_ext + sudo python ./setup.py install + python ./test.py + +Note: if FLINT is not installed globally, you can do something like the following (the second +line is required for loading FLINT from Python):: + + python ./setup.py build_ext --include-dirs=/home/fredrik/src/flint2 --library-dirs=/home/fredrik/src/flint2 + export LD_LIBRARY_PATH=/home/fredrik/src/flint2/:$LD_LIBRARY_PATH + +If everything worked, you will be able to import the ``flint`` module +in Python:: + + Python 2.7.3 (default, Apr 20 2012, 22:39:59) + [GCC 4.6.3] on linux2 + Type "help", "copyright", "credits" or "license" for more information. + >>> import flint + >>> flint.fmpz(33) ** 33 + fmpz(129110040087761027839616029934664535539337183380513) + +Reference +:::::::::::: + +Scalar types +............ + +fmpz +------------------------------------------------------------ + +.. autoclass :: flint.fmpz + :members: + :undoc-members: + +fmpq +------------------------------------------------------------ + +.. autoclass :: flint.fmpq + :members: + :undoc-members: + +nmod +------------------------------------------------------------ + +.. autoclass :: flint.nmod + :members: + :undoc-members: + +Polynomial types +................ + +fmpz_poly +------------------------------------------------------------ + +.. autoclass :: flint.fmpz_poly + :members: + :undoc-members: + +fmpq_poly +------------------------------------------------------------ + +.. autoclass :: flint.fmpq_poly + :members: + :undoc-members: + +nmod_poly +------------------------------------------------------------ + +.. autoclass :: flint.nmod_poly + :members: + :undoc-members: + +Matrix types +............ + +fmpz_mat +------------------------------------------------------------ + +.. autoclass :: flint.fmpz_mat + :members: + :undoc-members: + +fmpq_mat +------------------------------------------------------------ + +.. autoclass :: flint.fmpq_mat + :members: + :undoc-members: + +nmod_mat +------------------------------------------------------------ + +.. autoclass :: flint.nmod_mat + :members: + :undoc-members: + +Special functions +................. + +.. autofunction :: flint.number_of_partitions diff --git a/doc/build/html/_static/ajax-loader.gif b/doc/build/html/_static/ajax-loader.gif new file mode 100644 index 00000000..61faf8ca Binary files /dev/null and b/doc/build/html/_static/ajax-loader.gif differ diff --git a/doc/build/html/_static/basic.css b/doc/build/html/_static/basic.css new file mode 100644 index 00000000..43e8bafa --- /dev/null +++ b/doc/build/html/_static/basic.css @@ -0,0 +1,540 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox input[type="text"] { + width: 170px; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + width: 30px; +} + +img { + border: 0; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li div.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable dl, table.indextable dd { + margin-top: 0; + margin-bottom: 0; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- general body styles --------------------------------------------------- */ + +a.headerlink { + visibility: hidden; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.field-list ul { + padding-left: 1em; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px 7px 0 7px; + background-color: #ffe; + width: 40%; + float: right; +} + +p.sidebar-title { + font-weight: bold; +} + +/* -- topics ---------------------------------------------------------------- */ + +div.topic { + border: 1px solid #ccc; + padding: 7px 7px 0 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +div.admonition dl { + margin-bottom: 0; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + border: 0; + border-collapse: collapse; +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +table.field-list td, table.field-list th { + border: 0 !important; +} + +table.footnote td, table.footnote th { + border: 0 !important; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +dl { + margin-bottom: 15px; +} + +dd p { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +dt:target, .highlighted { + background-color: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.refcount { + color: #060; +} + +.optional { + font-size: 1.3em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +td.linenos pre { + padding: 5px 0px; + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + margin-left: 0.5em; +} + +table.highlighttable td { + padding: 0 0.5em 0 0.5em; +} + +tt.descname { + background-color: transparent; + font-weight: bold; + font-size: 1.2em; +} + +tt.descclassname { + background-color: transparent; +} + +tt.xref, a tt { + background-color: transparent; + font-weight: bold; +} + +h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/doc/build/html/_static/comment-bright.png b/doc/build/html/_static/comment-bright.png new file mode 100644 index 00000000..551517b8 Binary files /dev/null and b/doc/build/html/_static/comment-bright.png differ diff --git a/doc/build/html/_static/comment-close.png b/doc/build/html/_static/comment-close.png new file mode 100644 index 00000000..09b54be4 Binary files /dev/null and b/doc/build/html/_static/comment-close.png differ diff --git a/doc/build/html/_static/comment.png b/doc/build/html/_static/comment.png new file mode 100644 index 00000000..92feb52b Binary files /dev/null and b/doc/build/html/_static/comment.png differ diff --git a/doc/build/html/_static/default.css b/doc/build/html/_static/default.css new file mode 100644 index 00000000..21f3f509 --- /dev/null +++ b/doc/build/html/_static/default.css @@ -0,0 +1,256 @@ +/* + * default.css_t + * ~~~~~~~~~~~~~ + * + * Sphinx stylesheet -- default theme. + * + * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +@import url("basic.css"); + +/* -- page layout ----------------------------------------------------------- */ + +body { + font-family: sans-serif; + font-size: 100%; + background-color: #11303d; + color: #000; + margin: 0; + padding: 0; +} + +div.document { + background-color: #1c4e63; +} + +div.documentwrapper { + float: left; + width: 100%; +} + +div.bodywrapper { + margin: 0 0 0 230px; +} + +div.body { + background-color: #ffffff; + color: #000000; + padding: 0 20px 30px 20px; +} + +div.footer { + color: #ffffff; + width: 100%; + padding: 9px 0 9px 0; + text-align: center; + font-size: 75%; +} + +div.footer a { + color: #ffffff; + text-decoration: underline; +} + +div.related { + background-color: #133f52; + line-height: 30px; + color: #ffffff; +} + +div.related a { + color: #ffffff; +} + +div.sphinxsidebar { +} + +div.sphinxsidebar h3 { + font-family: 'Trebuchet MS', sans-serif; + color: #ffffff; + font-size: 1.4em; + font-weight: normal; + margin: 0; + padding: 0; +} + +div.sphinxsidebar h3 a { + color: #ffffff; +} + +div.sphinxsidebar h4 { + font-family: 'Trebuchet MS', sans-serif; + color: #ffffff; + font-size: 1.3em; + font-weight: normal; + margin: 5px 0 0 0; + padding: 0; +} + +div.sphinxsidebar p { + color: #ffffff; +} + +div.sphinxsidebar p.topless { + margin: 5px 10px 10px 10px; +} + +div.sphinxsidebar ul { + margin: 10px; + padding: 0; + color: #ffffff; +} + +div.sphinxsidebar a { + color: #98dbcc; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + + + +/* -- hyperlink styles ------------------------------------------------------ */ + +a { + color: #355f7c; + text-decoration: none; +} + +a:visited { + color: #355f7c; + text-decoration: none; +} + +a:hover { + text-decoration: underline; +} + + + +/* -- body styles ----------------------------------------------------------- */ + +div.body h1, +div.body h2, +div.body h3, +div.body h4, +div.body h5, +div.body h6 { + font-family: 'Trebuchet MS', sans-serif; + background-color: #f2f2f2; + font-weight: normal; + color: #20435c; + border-bottom: 1px solid #ccc; + margin: 20px -20px 10px -20px; + padding: 3px 0 3px 10px; +} + +div.body h1 { margin-top: 0; font-size: 200%; } +div.body h2 { font-size: 160%; } +div.body h3 { font-size: 140%; } +div.body h4 { font-size: 120%; } +div.body h5 { font-size: 110%; } +div.body h6 { font-size: 100%; } + +a.headerlink { + color: #c60f0f; + font-size: 0.8em; + padding: 0 4px 0 4px; + text-decoration: none; +} + +a.headerlink:hover { + background-color: #c60f0f; + color: white; +} + +div.body p, div.body dd, div.body li { + text-align: justify; + line-height: 130%; +} + +div.admonition p.admonition-title + p { + display: inline; +} + +div.admonition p { + margin-bottom: 5px; +} + +div.admonition pre { + margin-bottom: 5px; +} + +div.admonition ul, div.admonition ol { + margin-bottom: 5px; +} + +div.note { + background-color: #eee; + border: 1px solid #ccc; +} + +div.seealso { + background-color: #ffc; + border: 1px solid #ff6; +} + +div.topic { + background-color: #eee; +} + +div.warning { + background-color: #ffe4e4; + border: 1px solid #f66; +} + +p.admonition-title { + display: inline; +} + +p.admonition-title:after { + content: ":"; +} + +pre { + padding: 5px; + background-color: #eeffcc; + color: #333333; + line-height: 120%; + border: 1px solid #ac9; + border-left: none; + border-right: none; +} + +tt { + background-color: #ecf0f3; + padding: 0 1px 0 1px; + font-size: 0.95em; +} + +th { + background-color: #ede; +} + +.warning tt { + background: #efc2c2; +} + +.note tt { + background: #d6d6d6; +} + +.viewcode-back { + font-family: sans-serif; +} + +div.viewcode-block:target { + background-color: #f4debf; + border-top: 1px solid #ac9; + border-bottom: 1px solid #ac9; +} \ No newline at end of file diff --git a/doc/build/html/_static/doctools.js b/doc/build/html/_static/doctools.js new file mode 100644 index 00000000..d4619fdf --- /dev/null +++ b/doc/build/html/_static/doctools.js @@ -0,0 +1,247 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for all documentation. + * + * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/** + * select a different prefix for underscore + */ +$u = _.noConflict(); + +/** + * make the code below compatible with browsers without + * an installed firebug like debugger +if (!window.console || !console.firebug) { + var names = ["log", "debug", "info", "warn", "error", "assert", "dir", + "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace", + "profile", "profileEnd"]; + window.console = {}; + for (var i = 0; i < names.length; ++i) + window.console[names[i]] = function() {}; +} + */ + +/** + * small helper function to urldecode strings + */ +jQuery.urldecode = function(x) { + return decodeURIComponent(x).replace(/\+/g, ' '); +} + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s == 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * small function to check if an array contains + * a given item. + */ +jQuery.contains = function(arr, item) { + for (var i = 0; i < arr.length; i++) { + if (arr[i] == item) + return true; + } + return false; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node) { + if (node.nodeType == 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && !jQuery(node.parentNode).hasClass(className)) { + var span = document.createElement("span"); + span.className = className; + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this); + }); + } + } + return this.each(function() { + highlight(this); + }); +}; + +/** + * Small JavaScript module for the documentation. + */ +var Documentation = { + + init : function() { + this.fixFirefoxAnchorBug(); + this.highlightSearchWords(); + this.initIndexTable(); + }, + + /** + * i18n support + */ + TRANSLATIONS : {}, + PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; }, + LOCALE : 'unknown', + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext : function(string) { + var translated = Documentation.TRANSLATIONS[string]; + if (typeof translated == 'undefined') + return string; + return (typeof translated == 'string') ? translated : translated[0]; + }, + + ngettext : function(singular, plural, n) { + var translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated == 'undefined') + return (n == 1) ? singular : plural; + return translated[Documentation.PLURALEXPR(n)]; + }, + + addTranslations : function(catalog) { + for (var key in catalog.messages) + this.TRANSLATIONS[key] = catalog.messages[key]; + this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')'); + this.LOCALE = catalog.locale; + }, + + /** + * add context elements like header anchor links + */ + addContextElements : function() { + $('div[id] > :header:first').each(function() { + $('\u00B6'). + attr('href', '#' + this.id). + attr('title', _('Permalink to this headline')). + appendTo(this); + }); + $('dt[id]').each(function() { + $('\u00B6'). + attr('href', '#' + this.id). + attr('title', _('Permalink to this definition')). + appendTo(this); + }); + }, + + /** + * workaround a firefox stupidity + */ + fixFirefoxAnchorBug : function() { + if (document.location.hash && $.browser.mozilla) + window.setTimeout(function() { + document.location.href += ''; + }, 10); + }, + + /** + * highlight the search words provided in the url in the text + */ + highlightSearchWords : function() { + var params = $.getQueryParameters(); + var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : []; + if (terms.length) { + var body = $('div.body'); + window.setTimeout(function() { + $.each(terms, function() { + body.highlightText(this.toLowerCase(), 'highlighted'); + }); + }, 10); + $('

' + _('Hide Search Matches') + '

') + .appendTo($('#searchbox')); + } + }, + + /** + * init the domain index toggle buttons + */ + initIndexTable : function() { + var togglers = $('img.toggler').click(function() { + var src = $(this).attr('src'); + var idnum = $(this).attr('id').substr(7); + $('tr.cg-' + idnum).toggle(); + if (src.substr(-9) == 'minus.png') + $(this).attr('src', src.substr(0, src.length-9) + 'plus.png'); + else + $(this).attr('src', src.substr(0, src.length-8) + 'minus.png'); + }).css('display', ''); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) { + togglers.click(); + } + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords : function() { + $('#searchbox .highlight-link').fadeOut(300); + $('span.highlighted').removeClass('highlighted'); + }, + + /** + * make the url absolute + */ + makeURL : function(relativeURL) { + return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL; + }, + + /** + * get the current relative url + */ + getCurrentURL : function() { + var path = document.location.pathname; + var parts = path.split(/\//); + $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() { + if (this == '..') + parts.pop(); + }); + var url = parts.join('/'); + return path.substring(url.lastIndexOf('/') + 1, path.length - 1); + } +}; + +// quick alias for translations +_ = Documentation.gettext; + +$(document).ready(function() { + Documentation.init(); +}); diff --git a/doc/build/html/_static/down-pressed.png b/doc/build/html/_static/down-pressed.png new file mode 100644 index 00000000..6f7ad782 Binary files /dev/null and b/doc/build/html/_static/down-pressed.png differ diff --git a/doc/build/html/_static/down.png b/doc/build/html/_static/down.png new file mode 100644 index 00000000..3003a887 Binary files /dev/null and b/doc/build/html/_static/down.png differ diff --git a/doc/build/html/_static/file.png b/doc/build/html/_static/file.png new file mode 100644 index 00000000..d18082e3 Binary files /dev/null and b/doc/build/html/_static/file.png differ diff --git a/doc/build/html/_static/jquery.js b/doc/build/html/_static/jquery.js new file mode 100644 index 00000000..7c243080 --- /dev/null +++ b/doc/build/html/_static/jquery.js @@ -0,0 +1,154 @@ +/*! + * jQuery JavaScript Library v1.4.2 + * http://jquery.com/ + * + * Copyright 2010, John Resig + * Dual licensed under the MIT or GPL Version 2 licenses. + * http://jquery.org/license + * + * Includes Sizzle.js + * http://sizzlejs.com/ + * Copyright 2010, The Dojo Foundation + * Released under the MIT, BSD, and GPL Licenses. + * + * Date: Sat Feb 13 22:33:48 2010 -0500 + */ +(function(A,w){function ma(){if(!c.isReady){try{s.documentElement.doScroll("left")}catch(a){setTimeout(ma,1);return}c.ready()}}function Qa(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function X(a,b,d,f,e,j){var i=a.length;if(typeof b==="object"){for(var o in b)X(a,o,b[o],f,e,d);return a}if(d!==w){f=!j&&f&&c.isFunction(d);for(o=0;o)[^>]*$|^#([\w-]+)$/,Ua=/^.[^:#\[\.,]*$/,Va=/\S/, +Wa=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,Xa=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,P=navigator.userAgent,xa=false,Q=[],L,$=Object.prototype.toString,aa=Object.prototype.hasOwnProperty,ba=Array.prototype.push,R=Array.prototype.slice,ya=Array.prototype.indexOf;c.fn=c.prototype={init:function(a,b){var d,f;if(!a)return this;if(a.nodeType){this.context=this[0]=a;this.length=1;return this}if(a==="body"&&!b){this.context=s;this[0]=s.body;this.selector="body";this.length=1;return this}if(typeof a==="string")if((d=Ta.exec(a))&& +(d[1]||!b))if(d[1]){f=b?b.ownerDocument||b:s;if(a=Xa.exec(a))if(c.isPlainObject(b)){a=[s.createElement(a[1])];c.fn.attr.call(a,b,true)}else a=[f.createElement(a[1])];else{a=sa([d[1]],[f]);a=(a.cacheable?a.fragment.cloneNode(true):a.fragment).childNodes}return c.merge(this,a)}else{if(b=s.getElementById(d[2])){if(b.id!==d[2])return T.find(a);this.length=1;this[0]=b}this.context=s;this.selector=a;return this}else if(!b&&/^\w+$/.test(a)){this.selector=a;this.context=s;a=s.getElementsByTagName(a);return c.merge(this, +a)}else return!b||b.jquery?(b||T).find(a):c(b).find(a);else if(c.isFunction(a))return T.ready(a);if(a.selector!==w){this.selector=a.selector;this.context=a.context}return c.makeArray(a,this)},selector:"",jquery:"1.4.2",length:0,size:function(){return this.length},toArray:function(){return R.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this.slice(a)[0]:this[a]},pushStack:function(a,b,d){var f=c();c.isArray(a)?ba.apply(f,a):c.merge(f,a);f.prevObject=this;f.context=this.context;if(b=== +"find")f.selector=this.selector+(this.selector?" ":"")+d;else if(b)f.selector=this.selector+"."+b+"("+d+")";return f},each:function(a,b){return c.each(this,a,b)},ready:function(a){c.bindReady();if(c.isReady)a.call(s,c);else Q&&Q.push(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(R.apply(this,arguments),"slice",R.call(arguments).join(","))},map:function(a){return this.pushStack(c.map(this, +function(b,d){return a.call(b,d,b)}))},end:function(){return this.prevObject||c(null)},push:ba,sort:[].sort,splice:[].splice};c.fn.init.prototype=c.fn;c.extend=c.fn.extend=function(){var a=arguments[0]||{},b=1,d=arguments.length,f=false,e,j,i,o;if(typeof a==="boolean"){f=a;a=arguments[1]||{};b=2}if(typeof a!=="object"&&!c.isFunction(a))a={};if(d===b){a=this;--b}for(;b
a"; +var e=d.getElementsByTagName("*"),j=d.getElementsByTagName("a")[0];if(!(!e||!e.length||!j)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(j.getAttribute("style")),hrefNormalized:j.getAttribute("href")==="/a",opacity:/^0.55$/.test(j.style.opacity),cssFloat:!!j.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:s.createElement("select").appendChild(s.createElement("option")).selected, +parentNode:d.removeChild(d.appendChild(s.createElement("div"))).parentNode===null,deleteExpando:true,checkClone:false,scriptEval:false,noCloneEvent:true,boxModel:null};b.type="text/javascript";try{b.appendChild(s.createTextNode("window."+f+"=1;"))}catch(i){}a.insertBefore(b,a.firstChild);if(A[f]){c.support.scriptEval=true;delete A[f]}try{delete b.test}catch(o){c.support.deleteExpando=false}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function k(){c.support.noCloneEvent= +false;d.detachEvent("onclick",k)});d.cloneNode(true).fireEvent("onclick")}d=s.createElement("div");d.innerHTML="";a=s.createDocumentFragment();a.appendChild(d.firstChild);c.support.checkClone=a.cloneNode(true).cloneNode(true).lastChild.checked;c(function(){var k=s.createElement("div");k.style.width=k.style.paddingLeft="1px";s.body.appendChild(k);c.boxModel=c.support.boxModel=k.offsetWidth===2;s.body.removeChild(k).style.display="none"});a=function(k){var n= +s.createElement("div");k="on"+k;var r=k in n;if(!r){n.setAttribute(k,"return;");r=typeof n[k]==="function"}return r};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=e=j=null}})();c.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"};var G="jQuery"+J(),Ya=0,za={};c.extend({cache:{},expando:G,noData:{embed:true,object:true, +applet:true},data:function(a,b,d){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var f=a[G],e=c.cache;if(!f&&typeof b==="string"&&d===w)return null;f||(f=++Ya);if(typeof b==="object"){a[G]=f;e[f]=c.extend(true,{},b)}else if(!e[f]){a[G]=f;e[f]={}}a=e[f];if(d!==w)a[b]=d;return typeof b==="string"?a[b]:a}},removeData:function(a,b){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var d=a[G],f=c.cache,e=f[d];if(b){if(e){delete e[b];c.isEmptyObject(e)&&c.removeData(a)}}else{if(c.support.deleteExpando)delete a[c.expando]; +else a.removeAttribute&&a.removeAttribute(c.expando);delete f[d]}}}});c.fn.extend({data:function(a,b){if(typeof a==="undefined"&&this.length)return c.data(this[0]);else if(typeof a==="object")return this.each(function(){c.data(this,a)});var d=a.split(".");d[1]=d[1]?"."+d[1]:"";if(b===w){var f=this.triggerHandler("getData"+d[1]+"!",[d[0]]);if(f===w&&this.length)f=c.data(this[0],a);return f===w&&d[1]?this.data(d[0]):f}else return this.trigger("setData"+d[1]+"!",[d[0],b]).each(function(){c.data(this, +a,b)})},removeData:function(a){return this.each(function(){c.removeData(this,a)})}});c.extend({queue:function(a,b,d){if(a){b=(b||"fx")+"queue";var f=c.data(a,b);if(!d)return f||[];if(!f||c.isArray(d))f=c.data(a,b,c.makeArray(d));else f.push(d);return f}},dequeue:function(a,b){b=b||"fx";var d=c.queue(a,b),f=d.shift();if(f==="inprogress")f=d.shift();if(f){b==="fx"&&d.unshift("inprogress");f.call(a,function(){c.dequeue(a,b)})}}});c.fn.extend({queue:function(a,b){if(typeof a!=="string"){b=a;a="fx"}if(b=== +w)return c.queue(this[0],a);return this.each(function(){var d=c.queue(this,a,b);a==="fx"&&d[0]!=="inprogress"&&c.dequeue(this,a)})},dequeue:function(a){return this.each(function(){c.dequeue(this,a)})},delay:function(a,b){a=c.fx?c.fx.speeds[a]||a:a;b=b||"fx";return this.queue(b,function(){var d=this;setTimeout(function(){c.dequeue(d,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var Aa=/[\n\t]/g,ca=/\s+/,Za=/\r/g,$a=/href|src|style/,ab=/(button|input)/i,bb=/(button|input|object|select|textarea)/i, +cb=/^(a|area)$/i,Ba=/radio|checkbox/;c.fn.extend({attr:function(a,b){return X(this,a,b,true,c.attr)},removeAttr:function(a){return this.each(function(){c.attr(this,a,"");this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(c.isFunction(a))return this.each(function(n){var r=c(this);r.addClass(a.call(this,n,r.attr("class")))});if(a&&typeof a==="string")for(var b=(a||"").split(ca),d=0,f=this.length;d-1)return true;return false},val:function(a){if(a===w){var b=this[0];if(b){if(c.nodeName(b,"option"))return(b.attributes.value||{}).specified?b.value:b.text;if(c.nodeName(b,"select")){var d=b.selectedIndex,f=[],e=b.options;b=b.type==="select-one";if(d<0)return null;var j=b?d:0;for(d=b?d+1:e.length;j=0;else if(c.nodeName(this,"select")){var u=c.makeArray(r);c("option",this).each(function(){this.selected= +c.inArray(c(this).val(),u)>=0});if(!u.length)this.selectedIndex=-1}else this.value=r}})}});c.extend({attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(a,b,d,f){if(!a||a.nodeType===3||a.nodeType===8)return w;if(f&&b in c.attrFn)return c(a)[b](d);f=a.nodeType!==1||!c.isXMLDoc(a);var e=d!==w;b=f&&c.props[b]||b;if(a.nodeType===1){var j=$a.test(b);if(b in a&&f&&!j){if(e){b==="type"&&ab.test(a.nodeName)&&a.parentNode&&c.error("type property can't be changed"); +a[b]=d}if(c.nodeName(a,"form")&&a.getAttributeNode(b))return a.getAttributeNode(b).nodeValue;if(b==="tabIndex")return(b=a.getAttributeNode("tabIndex"))&&b.specified?b.value:bb.test(a.nodeName)||cb.test(a.nodeName)&&a.href?0:w;return a[b]}if(!c.support.style&&f&&b==="style"){if(e)a.style.cssText=""+d;return a.style.cssText}e&&a.setAttribute(b,""+d);a=!c.support.hrefNormalized&&f&&j?a.getAttribute(b,2):a.getAttribute(b);return a===null?w:a}return c.style(a,b,d)}});var O=/\.(.*)$/,db=function(a){return a.replace(/[^\w\s\.\|`]/g, +function(b){return"\\"+b})};c.event={add:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){if(a.setInterval&&a!==A&&!a.frameElement)a=A;var e,j;if(d.handler){e=d;d=e.handler}if(!d.guid)d.guid=c.guid++;if(j=c.data(a)){var i=j.events=j.events||{},o=j.handle;if(!o)j.handle=o=function(){return typeof c!=="undefined"&&!c.event.triggered?c.event.handle.apply(o.elem,arguments):w};o.elem=a;b=b.split(" ");for(var k,n=0,r;k=b[n++];){j=e?c.extend({},e):{handler:d,data:f};if(k.indexOf(".")>-1){r=k.split("."); +k=r.shift();j.namespace=r.slice(0).sort().join(".")}else{r=[];j.namespace=""}j.type=k;j.guid=d.guid;var u=i[k],z=c.event.special[k]||{};if(!u){u=i[k]=[];if(!z.setup||z.setup.call(a,f,r,o)===false)if(a.addEventListener)a.addEventListener(k,o,false);else a.attachEvent&&a.attachEvent("on"+k,o)}if(z.add){z.add.call(a,j);if(!j.handler.guid)j.handler.guid=d.guid}u.push(j);c.event.global[k]=true}a=null}}},global:{},remove:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){var e,j=0,i,o,k,n,r,u,z=c.data(a), +C=z&&z.events;if(z&&C){if(b&&b.type){d=b.handler;b=b.type}if(!b||typeof b==="string"&&b.charAt(0)==="."){b=b||"";for(e in C)c.event.remove(a,e+b)}else{for(b=b.split(" ");e=b[j++];){n=e;i=e.indexOf(".")<0;o=[];if(!i){o=e.split(".");e=o.shift();k=new RegExp("(^|\\.)"+c.map(o.slice(0).sort(),db).join("\\.(?:.*\\.)?")+"(\\.|$)")}if(r=C[e])if(d){n=c.event.special[e]||{};for(B=f||0;B=0){a.type= +e=e.slice(0,-1);a.exclusive=true}if(!d){a.stopPropagation();c.event.global[e]&&c.each(c.cache,function(){this.events&&this.events[e]&&c.event.trigger(a,b,this.handle.elem)})}if(!d||d.nodeType===3||d.nodeType===8)return w;a.result=w;a.target=d;b=c.makeArray(b);b.unshift(a)}a.currentTarget=d;(f=c.data(d,"handle"))&&f.apply(d,b);f=d.parentNode||d.ownerDocument;try{if(!(d&&d.nodeName&&c.noData[d.nodeName.toLowerCase()]))if(d["on"+e]&&d["on"+e].apply(d,b)===false)a.result=false}catch(j){}if(!a.isPropagationStopped()&& +f)c.event.trigger(a,b,f,true);else if(!a.isDefaultPrevented()){f=a.target;var i,o=c.nodeName(f,"a")&&e==="click",k=c.event.special[e]||{};if((!k._default||k._default.call(d,a)===false)&&!o&&!(f&&f.nodeName&&c.noData[f.nodeName.toLowerCase()])){try{if(f[e]){if(i=f["on"+e])f["on"+e]=null;c.event.triggered=true;f[e]()}}catch(n){}if(i)f["on"+e]=i;c.event.triggered=false}}},handle:function(a){var b,d,f,e;a=arguments[0]=c.event.fix(a||A.event);a.currentTarget=this;b=a.type.indexOf(".")<0&&!a.exclusive; +if(!b){d=a.type.split(".");a.type=d.shift();f=new RegExp("(^|\\.)"+d.slice(0).sort().join("\\.(?:.*\\.)?")+"(\\.|$)")}e=c.data(this,"events");d=e[a.type];if(e&&d){d=d.slice(0);e=0;for(var j=d.length;e-1?c.map(a.options,function(f){return f.selected}).join("-"):"";else if(a.nodeName.toLowerCase()==="select")d=a.selectedIndex;return d},fa=function(a,b){var d=a.target,f,e;if(!(!da.test(d.nodeName)||d.readOnly)){f=c.data(d,"_change_data");e=Fa(d);if(a.type!=="focusout"||d.type!=="radio")c.data(d,"_change_data", +e);if(!(f===w||e===f))if(f!=null||e){a.type="change";return c.event.trigger(a,b,d)}}};c.event.special.change={filters:{focusout:fa,click:function(a){var b=a.target,d=b.type;if(d==="radio"||d==="checkbox"||b.nodeName.toLowerCase()==="select")return fa.call(this,a)},keydown:function(a){var b=a.target,d=b.type;if(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(d==="checkbox"||d==="radio")||d==="select-multiple")return fa.call(this,a)},beforeactivate:function(a){a=a.target;c.data(a, +"_change_data",Fa(a))}},setup:function(){if(this.type==="file")return false;for(var a in ea)c.event.add(this,a+".specialChange",ea[a]);return da.test(this.nodeName)},teardown:function(){c.event.remove(this,".specialChange");return da.test(this.nodeName)}};ea=c.event.special.change.filters}s.addEventListener&&c.each({focus:"focusin",blur:"focusout"},function(a,b){function d(f){f=c.event.fix(f);f.type=b;return c.event.handle.call(this,f)}c.event.special[b]={setup:function(){this.addEventListener(a, +d,true)},teardown:function(){this.removeEventListener(a,d,true)}}});c.each(["bind","one"],function(a,b){c.fn[b]=function(d,f,e){if(typeof d==="object"){for(var j in d)this[b](j,f,d[j],e);return this}if(c.isFunction(f)){e=f;f=w}var i=b==="one"?c.proxy(e,function(k){c(this).unbind(k,i);return e.apply(this,arguments)}):e;if(d==="unload"&&b!=="one")this.one(d,f,e);else{j=0;for(var o=this.length;j0){y=t;break}}t=t[g]}m[q]=y}}}var f=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g, +e=0,j=Object.prototype.toString,i=false,o=true;[0,0].sort(function(){o=false;return 0});var k=function(g,h,l,m){l=l||[];var q=h=h||s;if(h.nodeType!==1&&h.nodeType!==9)return[];if(!g||typeof g!=="string")return l;for(var p=[],v,t,y,S,H=true,M=x(h),I=g;(f.exec(""),v=f.exec(I))!==null;){I=v[3];p.push(v[1]);if(v[2]){S=v[3];break}}if(p.length>1&&r.exec(g))if(p.length===2&&n.relative[p[0]])t=ga(p[0]+p[1],h);else for(t=n.relative[p[0]]?[h]:k(p.shift(),h);p.length;){g=p.shift();if(n.relative[g])g+=p.shift(); +t=ga(g,t)}else{if(!m&&p.length>1&&h.nodeType===9&&!M&&n.match.ID.test(p[0])&&!n.match.ID.test(p[p.length-1])){v=k.find(p.shift(),h,M);h=v.expr?k.filter(v.expr,v.set)[0]:v.set[0]}if(h){v=m?{expr:p.pop(),set:z(m)}:k.find(p.pop(),p.length===1&&(p[0]==="~"||p[0]==="+")&&h.parentNode?h.parentNode:h,M);t=v.expr?k.filter(v.expr,v.set):v.set;if(p.length>0)y=z(t);else H=false;for(;p.length;){var D=p.pop();v=D;if(n.relative[D])v=p.pop();else D="";if(v==null)v=h;n.relative[D](y,v,M)}}else y=[]}y||(y=t);y||k.error(D|| +g);if(j.call(y)==="[object Array]")if(H)if(h&&h.nodeType===1)for(g=0;y[g]!=null;g++){if(y[g]&&(y[g]===true||y[g].nodeType===1&&E(h,y[g])))l.push(t[g])}else for(g=0;y[g]!=null;g++)y[g]&&y[g].nodeType===1&&l.push(t[g]);else l.push.apply(l,y);else z(y,l);if(S){k(S,q,l,m);k.uniqueSort(l)}return l};k.uniqueSort=function(g){if(B){i=o;g.sort(B);if(i)for(var h=1;h":function(g,h){var l=typeof h==="string";if(l&&!/\W/.test(h)){h=h.toLowerCase();for(var m=0,q=g.length;m=0))l||m.push(v);else if(l)h[p]=false;return false},ID:function(g){return g[1].replace(/\\/g,"")},TAG:function(g){return g[1].toLowerCase()}, +CHILD:function(g){if(g[1]==="nth"){var h=/(-?)(\d*)n((?:\+|-)?\d*)/.exec(g[2]==="even"&&"2n"||g[2]==="odd"&&"2n+1"||!/\D/.test(g[2])&&"0n+"+g[2]||g[2]);g[2]=h[1]+(h[2]||1)-0;g[3]=h[3]-0}g[0]=e++;return g},ATTR:function(g,h,l,m,q,p){h=g[1].replace(/\\/g,"");if(!p&&n.attrMap[h])g[1]=n.attrMap[h];if(g[2]==="~=")g[4]=" "+g[4]+" ";return g},PSEUDO:function(g,h,l,m,q){if(g[1]==="not")if((f.exec(g[3])||"").length>1||/^\w/.test(g[3]))g[3]=k(g[3],null,null,h);else{g=k.filter(g[3],h,l,true^q);l||m.push.apply(m, +g);return false}else if(n.match.POS.test(g[0])||n.match.CHILD.test(g[0]))return true;return g},POS:function(g){g.unshift(true);return g}},filters:{enabled:function(g){return g.disabled===false&&g.type!=="hidden"},disabled:function(g){return g.disabled===true},checked:function(g){return g.checked===true},selected:function(g){return g.selected===true},parent:function(g){return!!g.firstChild},empty:function(g){return!g.firstChild},has:function(g,h,l){return!!k(l[3],g).length},header:function(g){return/h\d/i.test(g.nodeName)}, +text:function(g){return"text"===g.type},radio:function(g){return"radio"===g.type},checkbox:function(g){return"checkbox"===g.type},file:function(g){return"file"===g.type},password:function(g){return"password"===g.type},submit:function(g){return"submit"===g.type},image:function(g){return"image"===g.type},reset:function(g){return"reset"===g.type},button:function(g){return"button"===g.type||g.nodeName.toLowerCase()==="button"},input:function(g){return/input|select|textarea|button/i.test(g.nodeName)}}, +setFilters:{first:function(g,h){return h===0},last:function(g,h,l,m){return h===m.length-1},even:function(g,h){return h%2===0},odd:function(g,h){return h%2===1},lt:function(g,h,l){return hl[3]-0},nth:function(g,h,l){return l[3]-0===h},eq:function(g,h,l){return l[3]-0===h}},filter:{PSEUDO:function(g,h,l,m){var q=h[1],p=n.filters[q];if(p)return p(g,l,h,m);else if(q==="contains")return(g.textContent||g.innerText||a([g])||"").indexOf(h[3])>=0;else if(q==="not"){h= +h[3];l=0;for(m=h.length;l=0}},ID:function(g,h){return g.nodeType===1&&g.getAttribute("id")===h},TAG:function(g,h){return h==="*"&&g.nodeType===1||g.nodeName.toLowerCase()===h},CLASS:function(g,h){return(" "+(g.className||g.getAttribute("class"))+" ").indexOf(h)>-1},ATTR:function(g,h){var l=h[1];g=n.attrHandle[l]?n.attrHandle[l](g):g[l]!=null?g[l]:g.getAttribute(l);l=g+"";var m=h[2];h=h[4];return g==null?m==="!=":m=== +"="?l===h:m==="*="?l.indexOf(h)>=0:m==="~="?(" "+l+" ").indexOf(h)>=0:!h?l&&g!==false:m==="!="?l!==h:m==="^="?l.indexOf(h)===0:m==="$="?l.substr(l.length-h.length)===h:m==="|="?l===h||l.substr(0,h.length+1)===h+"-":false},POS:function(g,h,l,m){var q=n.setFilters[h[2]];if(q)return q(g,l,h,m)}}},r=n.match.POS;for(var u in n.match){n.match[u]=new RegExp(n.match[u].source+/(?![^\[]*\])(?![^\(]*\))/.source);n.leftMatch[u]=new RegExp(/(^(?:.|\r|\n)*?)/.source+n.match[u].source.replace(/\\(\d+)/g,function(g, +h){return"\\"+(h-0+1)}))}var z=function(g,h){g=Array.prototype.slice.call(g,0);if(h){h.push.apply(h,g);return h}return g};try{Array.prototype.slice.call(s.documentElement.childNodes,0)}catch(C){z=function(g,h){h=h||[];if(j.call(g)==="[object Array]")Array.prototype.push.apply(h,g);else if(typeof g.length==="number")for(var l=0,m=g.length;l";var l=s.documentElement;l.insertBefore(g,l.firstChild);if(s.getElementById(h)){n.find.ID=function(m,q,p){if(typeof q.getElementById!=="undefined"&&!p)return(q=q.getElementById(m[1]))?q.id===m[1]||typeof q.getAttributeNode!=="undefined"&& +q.getAttributeNode("id").nodeValue===m[1]?[q]:w:[]};n.filter.ID=function(m,q){var p=typeof m.getAttributeNode!=="undefined"&&m.getAttributeNode("id");return m.nodeType===1&&p&&p.nodeValue===q}}l.removeChild(g);l=g=null})();(function(){var g=s.createElement("div");g.appendChild(s.createComment(""));if(g.getElementsByTagName("*").length>0)n.find.TAG=function(h,l){l=l.getElementsByTagName(h[1]);if(h[1]==="*"){h=[];for(var m=0;l[m];m++)l[m].nodeType===1&&h.push(l[m]);l=h}return l};g.innerHTML=""; +if(g.firstChild&&typeof g.firstChild.getAttribute!=="undefined"&&g.firstChild.getAttribute("href")!=="#")n.attrHandle.href=function(h){return h.getAttribute("href",2)};g=null})();s.querySelectorAll&&function(){var g=k,h=s.createElement("div");h.innerHTML="

";if(!(h.querySelectorAll&&h.querySelectorAll(".TEST").length===0)){k=function(m,q,p,v){q=q||s;if(!v&&q.nodeType===9&&!x(q))try{return z(q.querySelectorAll(m),p)}catch(t){}return g(m,q,p,v)};for(var l in g)k[l]=g[l];h=null}}(); +(function(){var g=s.createElement("div");g.innerHTML="
";if(!(!g.getElementsByClassName||g.getElementsByClassName("e").length===0)){g.lastChild.className="e";if(g.getElementsByClassName("e").length!==1){n.order.splice(1,0,"CLASS");n.find.CLASS=function(h,l,m){if(typeof l.getElementsByClassName!=="undefined"&&!m)return l.getElementsByClassName(h[1])};g=null}}})();var E=s.compareDocumentPosition?function(g,h){return!!(g.compareDocumentPosition(h)&16)}: +function(g,h){return g!==h&&(g.contains?g.contains(h):true)},x=function(g){return(g=(g?g.ownerDocument||g:0).documentElement)?g.nodeName!=="HTML":false},ga=function(g,h){var l=[],m="",q;for(h=h.nodeType?[h]:h;q=n.match.PSEUDO.exec(g);){m+=q[0];g=g.replace(n.match.PSEUDO,"")}g=n.relative[g]?g+"*":g;q=0;for(var p=h.length;q=0===d})};c.fn.extend({find:function(a){for(var b=this.pushStack("","find",a),d=0,f=0,e=this.length;f0)for(var j=d;j0},closest:function(a,b){if(c.isArray(a)){var d=[],f=this[0],e,j= +{},i;if(f&&a.length){e=0;for(var o=a.length;e-1:c(f).is(e)){d.push({selector:i,elem:f});delete j[i]}}f=f.parentNode}}return d}var k=c.expr.match.POS.test(a)?c(a,b||this.context):null;return this.map(function(n,r){for(;r&&r.ownerDocument&&r!==b;){if(k?k.index(r)>-1:c(r).is(a))return r;r=r.parentNode}return null})},index:function(a){if(!a||typeof a=== +"string")return c.inArray(this[0],a?c(a):this.parent().children());return c.inArray(a.jquery?a[0]:a,this)},add:function(a,b){a=typeof a==="string"?c(a,b||this.context):c.makeArray(a);b=c.merge(this.get(),a);return this.pushStack(qa(a[0])||qa(b[0])?b:c.unique(b))},andSelf:function(){return this.add(this.prevObject)}});c.each({parent:function(a){return(a=a.parentNode)&&a.nodeType!==11?a:null},parents:function(a){return c.dir(a,"parentNode")},parentsUntil:function(a,b,d){return c.dir(a,"parentNode", +d)},next:function(a){return c.nth(a,2,"nextSibling")},prev:function(a){return c.nth(a,2,"previousSibling")},nextAll:function(a){return c.dir(a,"nextSibling")},prevAll:function(a){return c.dir(a,"previousSibling")},nextUntil:function(a,b,d){return c.dir(a,"nextSibling",d)},prevUntil:function(a,b,d){return c.dir(a,"previousSibling",d)},siblings:function(a){return c.sibling(a.parentNode.firstChild,a)},children:function(a){return c.sibling(a.firstChild)},contents:function(a){return c.nodeName(a,"iframe")? +a.contentDocument||a.contentWindow.document:c.makeArray(a.childNodes)}},function(a,b){c.fn[a]=function(d,f){var e=c.map(this,b,d);eb.test(a)||(f=d);if(f&&typeof f==="string")e=c.filter(f,e);e=this.length>1?c.unique(e):e;if((this.length>1||gb.test(f))&&fb.test(a))e=e.reverse();return this.pushStack(e,a,R.call(arguments).join(","))}});c.extend({filter:function(a,b,d){if(d)a=":not("+a+")";return c.find.matches(a,b)},dir:function(a,b,d){var f=[];for(a=a[b];a&&a.nodeType!==9&&(d===w||a.nodeType!==1||!c(a).is(d));){a.nodeType=== +1&&f.push(a);a=a[b]}return f},nth:function(a,b,d){b=b||1;for(var f=0;a;a=a[d])if(a.nodeType===1&&++f===b)break;return a},sibling:function(a,b){for(var d=[];a;a=a.nextSibling)a.nodeType===1&&a!==b&&d.push(a);return d}});var Ja=/ jQuery\d+="(?:\d+|null)"/g,V=/^\s+/,Ka=/(<([\w:]+)[^>]*?)\/>/g,hb=/^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,La=/<([\w:]+)/,ib=/"},F={option:[1,""],legend:[1,"
","
"],thead:[1,"","
"],tr:[2,"","
"],td:[3,"","
"],col:[2,"","
"],area:[1,"",""],_default:[0,"",""]};F.optgroup=F.option;F.tbody=F.tfoot=F.colgroup=F.caption=F.thead;F.th=F.td;if(!c.support.htmlSerialize)F._default=[1,"div
","
"];c.fn.extend({text:function(a){if(c.isFunction(a))return this.each(function(b){var d= +c(this);d.text(a.call(this,b,d.text()))});if(typeof a!=="object"&&a!==w)return this.empty().append((this[0]&&this[0].ownerDocument||s).createTextNode(a));return c.text(this)},wrapAll:function(a){if(c.isFunction(a))return this.each(function(d){c(this).wrapAll(a.call(this,d))});if(this[0]){var b=c(a,this[0].ownerDocument).eq(0).clone(true);this[0].parentNode&&b.insertBefore(this[0]);b.map(function(){for(var d=this;d.firstChild&&d.firstChild.nodeType===1;)d=d.firstChild;return d}).append(this)}return this}, +wrapInner:function(a){if(c.isFunction(a))return this.each(function(b){c(this).wrapInner(a.call(this,b))});return this.each(function(){var b=c(this),d=b.contents();d.length?d.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){c(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){c.nodeName(this,"body")||c(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.appendChild(a)})}, +prepend:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this)});else if(arguments.length){var a=c(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b, +this.nextSibling)});else if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,c(arguments[0]).toArray());return a}},remove:function(a,b){for(var d=0,f;(f=this[d])!=null;d++)if(!a||c.filter(a,[f]).length){if(!b&&f.nodeType===1){c.cleanData(f.getElementsByTagName("*"));c.cleanData([f])}f.parentNode&&f.parentNode.removeChild(f)}return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++)for(b.nodeType===1&&c.cleanData(b.getElementsByTagName("*"));b.firstChild;)b.removeChild(b.firstChild); +return this},clone:function(a){var b=this.map(function(){if(!c.support.noCloneEvent&&!c.isXMLDoc(this)){var d=this.outerHTML,f=this.ownerDocument;if(!d){d=f.createElement("div");d.appendChild(this.cloneNode(true));d=d.innerHTML}return c.clean([d.replace(Ja,"").replace(/=([^="'>\s]+\/)>/g,'="$1">').replace(V,"")],f)[0]}else return this.cloneNode(true)});if(a===true){ra(this,b);ra(this.find("*"),b.find("*"))}return b},html:function(a){if(a===w)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(Ja, +""):null;else if(typeof a==="string"&&!ta.test(a)&&(c.support.leadingWhitespace||!V.test(a))&&!F[(La.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Ka,Ma);try{for(var b=0,d=this.length;b0||e.cacheable||this.length>1?k.cloneNode(true):k)}o.length&&c.each(o,Qa)}return this}});c.fragments={};c.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){c.fn[a]=function(d){var f=[];d=c(d);var e=this.length===1&&this[0].parentNode;if(e&&e.nodeType===11&&e.childNodes.length===1&&d.length===1){d[b](this[0]); +return this}else{e=0;for(var j=d.length;e0?this.clone(true):this).get();c.fn[b].apply(c(d[e]),i);f=f.concat(i)}return this.pushStack(f,a,d.selector)}}});c.extend({clean:function(a,b,d,f){b=b||s;if(typeof b.createElement==="undefined")b=b.ownerDocument||b[0]&&b[0].ownerDocument||s;for(var e=[],j=0,i;(i=a[j])!=null;j++){if(typeof i==="number")i+="";if(i){if(typeof i==="string"&&!jb.test(i))i=b.createTextNode(i);else if(typeof i==="string"){i=i.replace(Ka,Ma);var o=(La.exec(i)||["", +""])[1].toLowerCase(),k=F[o]||F._default,n=k[0],r=b.createElement("div");for(r.innerHTML=k[1]+i+k[2];n--;)r=r.lastChild;if(!c.support.tbody){n=ib.test(i);o=o==="table"&&!n?r.firstChild&&r.firstChild.childNodes:k[1]===""&&!n?r.childNodes:[];for(k=o.length-1;k>=0;--k)c.nodeName(o[k],"tbody")&&!o[k].childNodes.length&&o[k].parentNode.removeChild(o[k])}!c.support.leadingWhitespace&&V.test(i)&&r.insertBefore(b.createTextNode(V.exec(i)[0]),r.firstChild);i=r.childNodes}if(i.nodeType)e.push(i);else e= +c.merge(e,i)}}if(d)for(j=0;e[j];j++)if(f&&c.nodeName(e[j],"script")&&(!e[j].type||e[j].type.toLowerCase()==="text/javascript"))f.push(e[j].parentNode?e[j].parentNode.removeChild(e[j]):e[j]);else{e[j].nodeType===1&&e.splice.apply(e,[j+1,0].concat(c.makeArray(e[j].getElementsByTagName("script"))));d.appendChild(e[j])}return e},cleanData:function(a){for(var b,d,f=c.cache,e=c.event.special,j=c.support.deleteExpando,i=0,o;(o=a[i])!=null;i++)if(d=o[c.expando]){b=f[d];if(b.events)for(var k in b.events)e[k]? +c.event.remove(o,k):Ca(o,k,b.handle);if(j)delete o[c.expando];else o.removeAttribute&&o.removeAttribute(c.expando);delete f[d]}}});var kb=/z-?index|font-?weight|opacity|zoom|line-?height/i,Na=/alpha\([^)]*\)/,Oa=/opacity=([^)]*)/,ha=/float/i,ia=/-([a-z])/ig,lb=/([A-Z])/g,mb=/^-?\d+(?:px)?$/i,nb=/^-?\d/,ob={position:"absolute",visibility:"hidden",display:"block"},pb=["Left","Right"],qb=["Top","Bottom"],rb=s.defaultView&&s.defaultView.getComputedStyle,Pa=c.support.cssFloat?"cssFloat":"styleFloat",ja= +function(a,b){return b.toUpperCase()};c.fn.css=function(a,b){return X(this,a,b,true,function(d,f,e){if(e===w)return c.curCSS(d,f);if(typeof e==="number"&&!kb.test(f))e+="px";c.style(d,f,e)})};c.extend({style:function(a,b,d){if(!a||a.nodeType===3||a.nodeType===8)return w;if((b==="width"||b==="height")&&parseFloat(d)<0)d=w;var f=a.style||a,e=d!==w;if(!c.support.opacity&&b==="opacity"){if(e){f.zoom=1;b=parseInt(d,10)+""==="NaN"?"":"alpha(opacity="+d*100+")";a=f.filter||c.curCSS(a,"filter")||"";f.filter= +Na.test(a)?a.replace(Na,b):b}return f.filter&&f.filter.indexOf("opacity=")>=0?parseFloat(Oa.exec(f.filter)[1])/100+"":""}if(ha.test(b))b=Pa;b=b.replace(ia,ja);if(e)f[b]=d;return f[b]},css:function(a,b,d,f){if(b==="width"||b==="height"){var e,j=b==="width"?pb:qb;function i(){e=b==="width"?a.offsetWidth:a.offsetHeight;f!=="border"&&c.each(j,function(){f||(e-=parseFloat(c.curCSS(a,"padding"+this,true))||0);if(f==="margin")e+=parseFloat(c.curCSS(a,"margin"+this,true))||0;else e-=parseFloat(c.curCSS(a, +"border"+this+"Width",true))||0})}a.offsetWidth!==0?i():c.swap(a,ob,i);return Math.max(0,Math.round(e))}return c.curCSS(a,b,d)},curCSS:function(a,b,d){var f,e=a.style;if(!c.support.opacity&&b==="opacity"&&a.currentStyle){f=Oa.test(a.currentStyle.filter||"")?parseFloat(RegExp.$1)/100+"":"";return f===""?"1":f}if(ha.test(b))b=Pa;if(!d&&e&&e[b])f=e[b];else if(rb){if(ha.test(b))b="float";b=b.replace(lb,"-$1").toLowerCase();e=a.ownerDocument.defaultView;if(!e)return null;if(a=e.getComputedStyle(a,null))f= +a.getPropertyValue(b);if(b==="opacity"&&f==="")f="1"}else if(a.currentStyle){d=b.replace(ia,ja);f=a.currentStyle[b]||a.currentStyle[d];if(!mb.test(f)&&nb.test(f)){b=e.left;var j=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;e.left=d==="fontSize"?"1em":f||0;f=e.pixelLeft+"px";e.left=b;a.runtimeStyle.left=j}}return f},swap:function(a,b,d){var f={};for(var e in b){f[e]=a.style[e];a.style[e]=b[e]}d.call(a);for(e in b)a.style[e]=f[e]}});if(c.expr&&c.expr.filters){c.expr.filters.hidden=function(a){var b= +a.offsetWidth,d=a.offsetHeight,f=a.nodeName.toLowerCase()==="tr";return b===0&&d===0&&!f?true:b>0&&d>0&&!f?false:c.curCSS(a,"display")==="none"};c.expr.filters.visible=function(a){return!c.expr.filters.hidden(a)}}var sb=J(),tb=//gi,ub=/select|textarea/i,vb=/color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,N=/=\?(&|$)/,ka=/\?/,wb=/(\?|&)_=.*?(&|$)/,xb=/^(\w+:)?\/\/([^\/?#]+)/,yb=/%20/g,zb=c.fn.load;c.fn.extend({load:function(a,b,d){if(typeof a!== +"string")return zb.call(this,a);else if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var e=a.slice(f,a.length);a=a.slice(0,f)}f="GET";if(b)if(c.isFunction(b)){d=b;b=null}else if(typeof b==="object"){b=c.param(b,c.ajaxSettings.traditional);f="POST"}var j=this;c.ajax({url:a,type:f,dataType:"html",data:b,complete:function(i,o){if(o==="success"||o==="notmodified")j.html(e?c("
").append(i.responseText.replace(tb,"")).find(e):i.responseText);d&&j.each(d,[i.responseText,o,i])}});return this}, +serialize:function(){return c.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?c.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ub.test(this.nodeName)||vb.test(this.type))}).map(function(a,b){a=c(this).val();return a==null?null:c.isArray(a)?c.map(a,function(d){return{name:b.name,value:d}}):{name:b.name,value:a}}).get()}});c.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), +function(a,b){c.fn[b]=function(d){return this.bind(b,d)}});c.extend({get:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b=null}return c.ajax({type:"GET",url:a,data:b,success:d,dataType:f})},getScript:function(a,b){return c.get(a,null,b,"script")},getJSON:function(a,b,d){return c.get(a,b,d,"json")},post:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b={}}return c.ajax({type:"POST",url:a,data:b,success:d,dataType:f})},ajaxSetup:function(a){c.extend(c.ajaxSettings,a)},ajaxSettings:{url:location.href, +global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,xhr:A.XMLHttpRequest&&(A.location.protocol!=="file:"||!A.ActiveXObject)?function(){return new A.XMLHttpRequest}:function(){try{return new A.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}},accepts:{xml:"application/xml, text/xml",html:"text/html",script:"text/javascript, application/javascript",json:"application/json, text/javascript",text:"text/plain",_default:"*/*"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&& +e.success.call(k,o,i,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(k,x,i);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(q,p){(e.context?c(e.context):c.event).trigger(q,p)}var e=c.extend(true,{},c.ajaxSettings,a),j,i,o,k=a&&a.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,e.traditional);if(e.dataType==="jsonp"){if(n==="GET")N.test(e.url)||(e.url+=(ka.test(e.url)? +"&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!N.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&N.test(e.data)||N.test(e.url))){j=e.jsonpCallback||"jsonp"+sb++;if(e.data)e.data=(e.data+"").replace(N,"="+j+"$1");e.url=e.url.replace(N,"="+j+"$1");e.dataType="script";A[j]=A[j]||function(q){o=q;b();d();A[j]=w;try{delete A[j]}catch(p){}z&&z.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache=== +false&&n==="GET"){var r=J(),u=e.url.replace(wb,"$1_="+r+"$2");e.url=u+(u===e.url?(ka.test(e.url)?"&":"?")+"_="+r:"")}if(e.data&&n==="GET")e.url+=(ka.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");r=(r=xb.exec(e.url))&&(r[1]&&r[1]!==location.protocol||r[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&r){var z=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!j){var B= +false;C.onload=C.onreadystatechange=function(){if(!B&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){B=true;b();d();C.onload=C.onreadystatechange=null;z&&C.parentNode&&z.removeChild(C)}}}z.insertBefore(C,z.firstChild);return w}var E=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since", +c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}r||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+", */*":e.accepts._default)}catch(ga){}if(e.beforeSend&&e.beforeSend.call(k,x,e)===false){e.global&&!--c.active&&c.event.trigger("ajaxStop");x.abort();return false}e.global&&f("ajaxSend",[x,e]);var g=x.onreadystatechange=function(q){if(!x||x.readyState===0||q==="abort"){E|| +d();E=true;if(x)x.onreadystatechange=c.noop}else if(!E&&x&&(x.readyState===4||q==="timeout")){E=true;x.onreadystatechange=c.noop;i=q==="timeout"?"timeout":!c.httpSuccess(x)?"error":e.ifModified&&c.httpNotModified(x,e.url)?"notmodified":"success";var p;if(i==="success")try{o=c.httpData(x,e.dataType,e)}catch(v){i="parsererror";p=v}if(i==="success"||i==="notmodified")j||b();else c.handleError(e,x,i,p);d();q==="timeout"&&x.abort();if(e.async)x=null}};try{var h=x.abort;x.abort=function(){x&&h.call(x); +g("abort")}}catch(l){}e.async&&e.timeout>0&&setTimeout(function(){x&&!E&&g("timeout")},e.timeout);try{x.send(n==="POST"||n==="PUT"||n==="DELETE"?e.data:null)}catch(m){c.handleError(e,x,null,m);d()}e.async||g();return x}},handleError:function(a,b,d,f){if(a.error)a.error.call(a.context||a,b,d,f);if(a.global)(a.context?c(a.context):c.event).trigger("ajaxError",[b,a,f])},active:0,httpSuccess:function(a){try{return!a.status&&location.protocol==="file:"||a.status>=200&&a.status<300||a.status===304||a.status=== +1223||a.status===0}catch(b){}return false},httpNotModified:function(a,b){var d=a.getResponseHeader("Last-Modified"),f=a.getResponseHeader("Etag");if(d)c.lastModified[b]=d;if(f)c.etag[b]=f;return a.status===304||a.status===0},httpData:function(a,b,d){var f=a.getResponseHeader("content-type")||"",e=b==="xml"||!b&&f.indexOf("xml")>=0;a=e?a.responseXML:a.responseText;e&&a.documentElement.nodeName==="parsererror"&&c.error("parsererror");if(d&&d.dataFilter)a=d.dataFilter(a,b);if(typeof a==="string")if(b=== +"json"||!b&&f.indexOf("json")>=0)a=c.parseJSON(a);else if(b==="script"||!b&&f.indexOf("javascript")>=0)c.globalEval(a);return a},param:function(a,b){function d(i,o){if(c.isArray(o))c.each(o,function(k,n){b||/\[\]$/.test(i)?f(i,n):d(i+"["+(typeof n==="object"||c.isArray(n)?k:"")+"]",n)});else!b&&o!=null&&typeof o==="object"?c.each(o,function(k,n){d(i+"["+k+"]",n)}):f(i,o)}function f(i,o){o=c.isFunction(o)?o():o;e[e.length]=encodeURIComponent(i)+"="+encodeURIComponent(o)}var e=[];if(b===w)b=c.ajaxSettings.traditional; +if(c.isArray(a)||a.jquery)c.each(a,function(){f(this.name,this.value)});else for(var j in a)d(j,a[j]);return e.join("&").replace(yb,"+")}});var la={},Ab=/toggle|show|hide/,Bb=/^([+-]=)?([\d+-.]+)(.*)$/,W,va=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];c.fn.extend({show:function(a,b){if(a||a===0)return this.animate(K("show",3),a,b);else{a=0;for(b=this.length;a").appendTo("body");f=e.css("display");if(f==="none")f="block";e.remove();la[d]=f}c.data(this[a],"olddisplay",f)}}a=0;for(b=this.length;a=0;f--)if(d[f].elem===this){b&&d[f](true);d.splice(f,1)}});b||this.dequeue();return this}});c.each({slideDown:K("show",1),slideUp:K("hide",1),slideToggle:K("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"}},function(a,b){c.fn[a]=function(d,f){return this.animate(b,d,f)}});c.extend({speed:function(a,b,d){var f=a&&typeof a==="object"?a:{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};f.duration=c.fx.off?0:typeof f.duration=== +"number"?f.duration:c.fx.speeds[f.duration]||c.fx.speeds._default;f.old=f.complete;f.complete=function(){f.queue!==false&&c(this).dequeue();c.isFunction(f.old)&&f.old.call(this)};return f},easing:{linear:function(a,b,d,f){return d+f*a},swing:function(a,b,d,f){return(-Math.cos(a*Math.PI)/2+0.5)*f+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]|| +c.fx.step._default)(this);if((this.prop==="height"||this.prop==="width")&&this.elem.style)this.elem.style.display="block"},cur:function(a){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];return(a=parseFloat(c.css(this.elem,this.prop,a)))&&a>-10000?a:parseFloat(c.curCSS(this.elem,this.prop))||0},custom:function(a,b,d){function f(j){return e.step(j)}this.startTime=J();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start; +this.pos=this.state=0;var e=this;f.elem=this.elem;if(f()&&c.timers.push(f)&&!W)W=setInterval(c.fx.tick,13)},show:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.show=true;this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur());c(this.elem).show()},hide:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(a){var b=J(),d=true;if(a||b>=this.options.duration+this.startTime){this.now= +this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var f in this.options.curAnim)if(this.options.curAnim[f]!==true)d=false;if(d){if(this.options.display!=null){this.elem.style.overflow=this.options.overflow;a=c.data(this.elem,"olddisplay");this.elem.style.display=a?a:this.options.display;if(c.css(this.elem,"display")==="none")this.elem.style.display="block"}this.options.hide&&c(this.elem).hide();if(this.options.hide||this.options.show)for(var e in this.options.curAnim)c.style(this.elem, +e,this.options.orig[e]);this.options.complete.call(this.elem)}return false}else{e=b-this.startTime;this.state=e/this.options.duration;a=this.options.easing||(c.easing.swing?"swing":"linear");this.pos=c.easing[this.options.specialEasing&&this.options.specialEasing[this.prop]||a](this.state,e,0,1,this.options.duration);this.now=this.start+(this.end-this.start)*this.pos;this.update()}return true}};c.extend(c.fx,{tick:function(){for(var a=c.timers,b=0;b
"; +a.insertBefore(b,a.firstChild);d=b.firstChild;f=d.firstChild;e=d.nextSibling.firstChild.firstChild;this.doesNotAddBorder=f.offsetTop!==5;this.doesAddBorderForTableAndCells=e.offsetTop===5;f.style.position="fixed";f.style.top="20px";this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15;f.style.position=f.style.top="";d.style.overflow="hidden";d.style.position="relative";this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5;this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==j;a.removeChild(b); +c.offset.initialize=c.noop},bodyOffset:function(a){var b=a.offsetTop,d=a.offsetLeft;c.offset.initialize();if(c.offset.doesNotIncludeMarginInBodyOffset){b+=parseFloat(c.curCSS(a,"marginTop",true))||0;d+=parseFloat(c.curCSS(a,"marginLeft",true))||0}return{top:b,left:d}},setOffset:function(a,b,d){if(/static/.test(c.curCSS(a,"position")))a.style.position="relative";var f=c(a),e=f.offset(),j=parseInt(c.curCSS(a,"top",true),10)||0,i=parseInt(c.curCSS(a,"left",true),10)||0;if(c.isFunction(b))b=b.call(a, +d,e);d={top:b.top-e.top+j,left:b.left-e.left+i};"using"in b?b.using.call(a,d):f.css(d)}};c.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),d=this.offset(),f=/^body|html$/i.test(b[0].nodeName)?{top:0,left:0}:b.offset();d.top-=parseFloat(c.curCSS(a,"marginTop",true))||0;d.left-=parseFloat(c.curCSS(a,"marginLeft",true))||0;f.top+=parseFloat(c.curCSS(b[0],"borderTopWidth",true))||0;f.left+=parseFloat(c.curCSS(b[0],"borderLeftWidth",true))||0;return{top:d.top- +f.top,left:d.left-f.left}},offsetParent:function(){return this.map(function(){for(var a=this.offsetParent||s.body;a&&!/^body|html$/i.test(a.nodeName)&&c.css(a,"position")==="static";)a=a.offsetParent;return a})}});c.each(["Left","Top"],function(a,b){var d="scroll"+b;c.fn[d]=function(f){var e=this[0],j;if(!e)return null;if(f!==w)return this.each(function(){if(j=wa(this))j.scrollTo(!a?f:c(j).scrollLeft(),a?f:c(j).scrollTop());else this[d]=f});else return(j=wa(e))?"pageXOffset"in j?j[a?"pageYOffset": +"pageXOffset"]:c.support.boxModel&&j.document.documentElement[d]||j.document.body[d]:e[d]}});c.each(["Height","Width"],function(a,b){var d=b.toLowerCase();c.fn["inner"+b]=function(){return this[0]?c.css(this[0],d,false,"padding"):null};c.fn["outer"+b]=function(f){return this[0]?c.css(this[0],d,false,f?"margin":"border"):null};c.fn[d]=function(f){var e=this[0];if(!e)return f==null?null:this;if(c.isFunction(f))return this.each(function(j){var i=c(this);i[d](f.call(this,j,i[d]()))});return"scrollTo"in +e&&e.document?e.document.compatMode==="CSS1Compat"&&e.document.documentElement["client"+b]||e.document.body["client"+b]:e.nodeType===9?Math.max(e.documentElement["client"+b],e.body["scroll"+b],e.documentElement["scroll"+b],e.body["offset"+b],e.documentElement["offset"+b]):f===w?c.css(e,d):this.css(d,typeof f==="string"?f:f+"px")}});A.jQuery=A.$=c})(window); diff --git a/doc/build/html/_static/minus.png b/doc/build/html/_static/minus.png new file mode 100644 index 00000000..da1c5620 Binary files /dev/null and b/doc/build/html/_static/minus.png differ diff --git a/doc/build/html/_static/plus.png b/doc/build/html/_static/plus.png new file mode 100644 index 00000000..b3cb3742 Binary files /dev/null and b/doc/build/html/_static/plus.png differ diff --git a/doc/build/html/_static/pygments.css b/doc/build/html/_static/pygments.css new file mode 100644 index 00000000..1a14f2ae --- /dev/null +++ b/doc/build/html/_static/pygments.css @@ -0,0 +1,62 @@ +.highlight .hll { background-color: #ffffcc } +.highlight { background: #eeffcc; } +.highlight .c { color: #408090; font-style: italic } /* Comment */ +.highlight .err { border: 1px solid #FF0000 } /* Error */ +.highlight .k { color: #007020; font-weight: bold } /* Keyword */ +.highlight .o { color: #666666 } /* Operator */ +.highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #007020 } /* Comment.Preproc */ +.highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */ +.highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */ +.highlight .gd { color: #A00000 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .gr { color: #FF0000 } /* Generic.Error */ +.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.highlight .gi { color: #00A000 } /* Generic.Inserted */ +.highlight .go { color: #303030 } /* Generic.Output */ +.highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */ +.highlight .gs { font-weight: bold } /* Generic.Strong */ +.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.highlight .gt { color: #0040D0 } /* Generic.Traceback */ +.highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */ +.highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */ +.highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */ +.highlight .kp { color: #007020 } /* Keyword.Pseudo */ +.highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */ +.highlight .kt { color: #902000 } /* Keyword.Type */ +.highlight .m { color: #208050 } /* Literal.Number */ +.highlight .s { color: #4070a0 } /* Literal.String */ +.highlight .na { color: #4070a0 } /* Name.Attribute */ +.highlight .nb { color: #007020 } /* Name.Builtin */ +.highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */ +.highlight .no { color: #60add5 } /* Name.Constant */ +.highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */ +.highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */ +.highlight .ne { color: #007020 } /* Name.Exception */ +.highlight .nf { color: #06287e } /* Name.Function */ +.highlight .nl { color: #002070; font-weight: bold } /* Name.Label */ +.highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */ +.highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */ +.highlight .nv { color: #bb60d5 } /* Name.Variable */ +.highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */ +.highlight .w { color: #bbbbbb } /* Text.Whitespace */ +.highlight .mf { color: #208050 } /* Literal.Number.Float */ +.highlight .mh { color: #208050 } /* Literal.Number.Hex */ +.highlight .mi { color: #208050 } /* Literal.Number.Integer */ +.highlight .mo { color: #208050 } /* Literal.Number.Oct */ +.highlight .sb { color: #4070a0 } /* Literal.String.Backtick */ +.highlight .sc { color: #4070a0 } /* Literal.String.Char */ +.highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #4070a0 } /* Literal.String.Double */ +.highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */ +.highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */ +.highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */ +.highlight .sx { color: #c65d09 } /* Literal.String.Other */ +.highlight .sr { color: #235388 } /* Literal.String.Regex */ +.highlight .s1 { color: #4070a0 } /* Literal.String.Single */ +.highlight .ss { color: #517918 } /* Literal.String.Symbol */ +.highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */ +.highlight .vc { color: #bb60d5 } /* Name.Variable.Class */ +.highlight .vg { color: #bb60d5 } /* Name.Variable.Global */ +.highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */ +.highlight .il { color: #208050 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/doc/build/html/_static/searchtools.js b/doc/build/html/_static/searchtools.js new file mode 100644 index 00000000..663be4c9 --- /dev/null +++ b/doc/build/html/_static/searchtools.js @@ -0,0 +1,560 @@ +/* + * searchtools.js_t + * ~~~~~~~~~~~~~~~~ + * + * Sphinx JavaScript utilties for the full-text search. + * + * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/** + * helper function to return a node containing the + * search summary for a given text. keywords is a list + * of stemmed words, hlwords is the list of normal, unstemmed + * words. the first one is used to find the occurance, the + * latter for highlighting it. + */ + +jQuery.makeSearchSummary = function(text, keywords, hlwords) { + var textLower = text.toLowerCase(); + var start = 0; + $.each(keywords, function() { + var i = textLower.indexOf(this.toLowerCase()); + if (i > -1) + start = i; + }); + start = Math.max(start - 120, 0); + var excerpt = ((start > 0) ? '...' : '') + + $.trim(text.substr(start, 240)) + + ((start + 240 - text.length) ? '...' : ''); + var rv = $('
').text(excerpt); + $.each(hlwords, function() { + rv = rv.highlightText(this, 'highlighted'); + }); + return rv; +} + + +/** + * Porter Stemmer + */ +var Stemmer = function() { + + var step2list = { + ational: 'ate', + tional: 'tion', + enci: 'ence', + anci: 'ance', + izer: 'ize', + bli: 'ble', + alli: 'al', + entli: 'ent', + eli: 'e', + ousli: 'ous', + ization: 'ize', + ation: 'ate', + ator: 'ate', + alism: 'al', + iveness: 'ive', + fulness: 'ful', + ousness: 'ous', + aliti: 'al', + iviti: 'ive', + biliti: 'ble', + logi: 'log' + }; + + var step3list = { + icate: 'ic', + ative: '', + alize: 'al', + iciti: 'ic', + ical: 'ic', + ful: '', + ness: '' + }; + + var c = "[^aeiou]"; // consonant + var v = "[aeiouy]"; // vowel + var C = c + "[^aeiouy]*"; // consonant sequence + var V = v + "[aeiou]*"; // vowel sequence + + var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0 + var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 + var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 + var s_v = "^(" + C + ")?" + v; // vowel in stem + + this.stemWord = function (w) { + var stem; + var suffix; + var firstch; + var origword = w; + + if (w.length < 3) + return w; + + var re; + var re2; + var re3; + var re4; + + firstch = w.substr(0,1); + if (firstch == "y") + w = firstch.toUpperCase() + w.substr(1); + + // Step 1a + re = /^(.+?)(ss|i)es$/; + re2 = /^(.+?)([^s])s$/; + + if (re.test(w)) + w = w.replace(re,"$1$2"); + else if (re2.test(w)) + w = w.replace(re2,"$1$2"); + + // Step 1b + re = /^(.+?)eed$/; + re2 = /^(.+?)(ed|ing)$/; + if (re.test(w)) { + var fp = re.exec(w); + re = new RegExp(mgr0); + if (re.test(fp[1])) { + re = /.$/; + w = w.replace(re,""); + } + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = new RegExp(s_v); + if (re2.test(stem)) { + w = stem; + re2 = /(at|bl|iz)$/; + re3 = new RegExp("([^aeiouylsz])\\1$"); + re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re2.test(w)) + w = w + "e"; + else if (re3.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + else if (re4.test(w)) + w = w + "e"; + } + } + + // Step 1c + re = /^(.+?)y$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(s_v); + if (re.test(stem)) + w = stem + "i"; + } + + // Step 2 + re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step2list[suffix]; + } + + // Step 3 + re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step3list[suffix]; + } + + // Step 4 + re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + re2 = /^(.+?)(s|t)(ion)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + if (re.test(stem)) + w = stem; + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = new RegExp(mgr1); + if (re2.test(stem)) + w = stem; + } + + // Step 5 + re = /^(.+?)e$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + re2 = new RegExp(meq1); + re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) + w = stem; + } + re = /ll$/; + re2 = new RegExp(mgr1); + if (re.test(w) && re2.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + + // and turn initial Y back to y + if (firstch == "y") + w = firstch.toLowerCase() + w.substr(1); + return w; + } +} + + +/** + * Search Module + */ +var Search = { + + _index : null, + _queued_query : null, + _pulse_status : -1, + + init : function() { + var params = $.getQueryParameters(); + if (params.q) { + var query = params.q[0]; + $('input[name="q"]')[0].value = query; + this.performSearch(query); + } + }, + + loadIndex : function(url) { + $.ajax({type: "GET", url: url, data: null, success: null, + dataType: "script", cache: true}); + }, + + setIndex : function(index) { + var q; + this._index = index; + if ((q = this._queued_query) !== null) { + this._queued_query = null; + Search.query(q); + } + }, + + hasIndex : function() { + return this._index !== null; + }, + + deferQuery : function(query) { + this._queued_query = query; + }, + + stopPulse : function() { + this._pulse_status = 0; + }, + + startPulse : function() { + if (this._pulse_status >= 0) + return; + function pulse() { + Search._pulse_status = (Search._pulse_status + 1) % 4; + var dotString = ''; + for (var i = 0; i < Search._pulse_status; i++) + dotString += '.'; + Search.dots.text(dotString); + if (Search._pulse_status > -1) + window.setTimeout(pulse, 500); + }; + pulse(); + }, + + /** + * perform a search for something + */ + performSearch : function(query) { + // create the required interface elements + this.out = $('#search-results'); + this.title = $('

' + _('Searching') + '

').appendTo(this.out); + this.dots = $('').appendTo(this.title); + this.status = $('

').appendTo(this.out); + this.output = $('
    ').appendTo(this.out); + + $('#search-progress').text(_('Preparing search...')); + this.startPulse(); + + // index already loaded, the browser was quick! + if (this.hasIndex()) + this.query(query); + else + this.deferQuery(query); + }, + + query : function(query) { + var stopwords = ["and","then","into","it","as","are","in","if","for","no","there","their","was","is","be","to","that","but","they","not","such","with","by","a","on","these","of","will","this","near","the","or","at"]; + + // Stem the searchterms and add them to the correct list + var stemmer = new Stemmer(); + var searchterms = []; + var excluded = []; + var hlterms = []; + var tmp = query.split(/\s+/); + var objectterms = []; + for (var i = 0; i < tmp.length; i++) { + if (tmp[i] != "") { + objectterms.push(tmp[i].toLowerCase()); + } + + if ($u.indexOf(stopwords, tmp[i]) != -1 || tmp[i].match(/^\d+$/) || + tmp[i] == "") { + // skip this "word" + continue; + } + // stem the word + var word = stemmer.stemWord(tmp[i]).toLowerCase(); + // select the correct list + if (word[0] == '-') { + var toAppend = excluded; + word = word.substr(1); + } + else { + var toAppend = searchterms; + hlterms.push(tmp[i].toLowerCase()); + } + // only add if not already in the list + if (!$.contains(toAppend, word)) + toAppend.push(word); + }; + var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" ")); + + // console.debug('SEARCH: searching for:'); + // console.info('required: ', searchterms); + // console.info('excluded: ', excluded); + + // prepare search + var filenames = this._index.filenames; + var titles = this._index.titles; + var terms = this._index.terms; + var fileMap = {}; + var files = null; + // different result priorities + var importantResults = []; + var objectResults = []; + var regularResults = []; + var unimportantResults = []; + $('#search-progress').empty(); + + // lookup as object + for (var i = 0; i < objectterms.length; i++) { + var others = [].concat(objectterms.slice(0,i), + objectterms.slice(i+1, objectterms.length)) + var results = this.performObjectSearch(objectterms[i], others); + // Assume first word is most likely to be the object, + // other words more likely to be in description. + // Therefore put matches for earlier words first. + // (Results are eventually used in reverse order). + objectResults = results[0].concat(objectResults); + importantResults = results[1].concat(importantResults); + unimportantResults = results[2].concat(unimportantResults); + } + + // perform the search on the required terms + for (var i = 0; i < searchterms.length; i++) { + var word = searchterms[i]; + // no match but word was a required one + if ((files = terms[word]) == null) + break; + if (files.length == undefined) { + files = [files]; + } + // create the mapping + for (var j = 0; j < files.length; j++) { + var file = files[j]; + if (file in fileMap) + fileMap[file].push(word); + else + fileMap[file] = [word]; + } + } + + // now check if the files don't contain excluded terms + for (var file in fileMap) { + var valid = true; + + // check if all requirements are matched + if (fileMap[file].length != searchterms.length) + continue; + + // ensure that none of the excluded terms is in the + // search result. + for (var i = 0; i < excluded.length; i++) { + if (terms[excluded[i]] == file || + $.contains(terms[excluded[i]] || [], file)) { + valid = false; + break; + } + } + + // if we have still a valid result we can add it + // to the result list + if (valid) + regularResults.push([filenames[file], titles[file], '', null]); + } + + // delete unused variables in order to not waste + // memory until list is retrieved completely + delete filenames, titles, terms; + + // now sort the regular results descending by title + regularResults.sort(function(a, b) { + var left = a[1].toLowerCase(); + var right = b[1].toLowerCase(); + return (left > right) ? -1 : ((left < right) ? 1 : 0); + }); + + // combine all results + var results = unimportantResults.concat(regularResults) + .concat(objectResults).concat(importantResults); + + // print the results + var resultCount = results.length; + function displayNextItem() { + // results left, load the summary and display it + if (results.length) { + var item = results.pop(); + var listItem = $('
  • '); + if (DOCUMENTATION_OPTIONS.FILE_SUFFIX == '') { + // dirhtml builder + var dirname = item[0] + '/'; + if (dirname.match(/\/index\/$/)) { + dirname = dirname.substring(0, dirname.length-6); + } else if (dirname == 'index/') { + dirname = ''; + } + listItem.append($('').attr('href', + DOCUMENTATION_OPTIONS.URL_ROOT + dirname + + highlightstring + item[2]).html(item[1])); + } else { + // normal html builders + listItem.append($('').attr('href', + item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX + + highlightstring + item[2]).html(item[1])); + } + if (item[3]) { + listItem.append($(' (' + item[3] + ')')); + Search.output.append(listItem); + listItem.slideDown(5, function() { + displayNextItem(); + }); + } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) { + $.get(DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' + + item[0] + '.txt', function(data) { + if (data != '') { + listItem.append($.makeSearchSummary(data, searchterms, hlterms)); + Search.output.append(listItem); + } + listItem.slideDown(5, function() { + displayNextItem(); + }); + }, "text"); + } else { + // no source available, just display title + Search.output.append(listItem); + listItem.slideDown(5, function() { + displayNextItem(); + }); + } + } + // search finished, update title and status message + else { + Search.stopPulse(); + Search.title.text(_('Search Results')); + if (!resultCount) + Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.')); + else + Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount)); + Search.status.fadeIn(500); + } + } + displayNextItem(); + }, + + performObjectSearch : function(object, otherterms) { + var filenames = this._index.filenames; + var objects = this._index.objects; + var objnames = this._index.objnames; + var titles = this._index.titles; + + var importantResults = []; + var objectResults = []; + var unimportantResults = []; + + for (var prefix in objects) { + for (var name in objects[prefix]) { + var fullname = (prefix ? prefix + '.' : '') + name; + if (fullname.toLowerCase().indexOf(object) > -1) { + var match = objects[prefix][name]; + var objname = objnames[match[1]][2]; + var title = titles[match[0]]; + // If more than one term searched for, we require other words to be + // found in the name/title/description + if (otherterms.length > 0) { + var haystack = (prefix + ' ' + name + ' ' + + objname + ' ' + title).toLowerCase(); + var allfound = true; + for (var i = 0; i < otherterms.length; i++) { + if (haystack.indexOf(otherterms[i]) == -1) { + allfound = false; + break; + } + } + if (!allfound) { + continue; + } + } + var descr = objname + _(', in ') + title; + anchor = match[3]; + if (anchor == '') + anchor = fullname; + else if (anchor == '-') + anchor = objnames[match[1]][1] + '-' + fullname; + result = [filenames[match[0]], fullname, '#'+anchor, descr]; + switch (match[2]) { + case 1: objectResults.push(result); break; + case 0: importantResults.push(result); break; + case 2: unimportantResults.push(result); break; + } + } + } + } + + // sort results descending + objectResults.sort(function(a, b) { + return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0); + }); + + importantResults.sort(function(a, b) { + return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0); + }); + + unimportantResults.sort(function(a, b) { + return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0); + }); + + return [importantResults, objectResults, unimportantResults] + } +} + +$(document).ready(function() { + Search.init(); +}); \ No newline at end of file diff --git a/doc/build/html/_static/sidebar.js b/doc/build/html/_static/sidebar.js new file mode 100644 index 00000000..a45e1926 --- /dev/null +++ b/doc/build/html/_static/sidebar.js @@ -0,0 +1,151 @@ +/* + * sidebar.js + * ~~~~~~~~~~ + * + * This script makes the Sphinx sidebar collapsible. + * + * .sphinxsidebar contains .sphinxsidebarwrapper. This script adds + * in .sphixsidebar, after .sphinxsidebarwrapper, the #sidebarbutton + * used to collapse and expand the sidebar. + * + * When the sidebar is collapsed the .sphinxsidebarwrapper is hidden + * and the width of the sidebar and the margin-left of the document + * are decreased. When the sidebar is expanded the opposite happens. + * This script saves a per-browser/per-session cookie used to + * remember the position of the sidebar among the pages. + * Once the browser is closed the cookie is deleted and the position + * reset to the default (expanded). + * + * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +$(function() { + // global elements used by the functions. + // the 'sidebarbutton' element is defined as global after its + // creation, in the add_sidebar_button function + var bodywrapper = $('.bodywrapper'); + var sidebar = $('.sphinxsidebar'); + var sidebarwrapper = $('.sphinxsidebarwrapper'); + + // for some reason, the document has no sidebar; do not run into errors + if (!sidebar.length) return; + + // original margin-left of the bodywrapper and width of the sidebar + // with the sidebar expanded + var bw_margin_expanded = bodywrapper.css('margin-left'); + var ssb_width_expanded = sidebar.width(); + + // margin-left of the bodywrapper and width of the sidebar + // with the sidebar collapsed + var bw_margin_collapsed = '.8em'; + var ssb_width_collapsed = '.8em'; + + // colors used by the current theme + var dark_color = $('.related').css('background-color'); + var light_color = $('.document').css('background-color'); + + function sidebar_is_collapsed() { + return sidebarwrapper.is(':not(:visible)'); + } + + function toggle_sidebar() { + if (sidebar_is_collapsed()) + expand_sidebar(); + else + collapse_sidebar(); + } + + function collapse_sidebar() { + sidebarwrapper.hide(); + sidebar.css('width', ssb_width_collapsed); + bodywrapper.css('margin-left', bw_margin_collapsed); + sidebarbutton.css({ + 'margin-left': '0', + 'height': bodywrapper.height() + }); + sidebarbutton.find('span').text('»'); + sidebarbutton.attr('title', _('Expand sidebar')); + document.cookie = 'sidebar=collapsed'; + } + + function expand_sidebar() { + bodywrapper.css('margin-left', bw_margin_expanded); + sidebar.css('width', ssb_width_expanded); + sidebarwrapper.show(); + sidebarbutton.css({ + 'margin-left': ssb_width_expanded-12, + 'height': bodywrapper.height() + }); + sidebarbutton.find('span').text('«'); + sidebarbutton.attr('title', _('Collapse sidebar')); + document.cookie = 'sidebar=expanded'; + } + + function add_sidebar_button() { + sidebarwrapper.css({ + 'float': 'left', + 'margin-right': '0', + 'width': ssb_width_expanded - 28 + }); + // create the button + sidebar.append( + '
    «
    ' + ); + var sidebarbutton = $('#sidebarbutton'); + light_color = sidebarbutton.css('background-color'); + // find the height of the viewport to center the '<<' in the page + var viewport_height; + if (window.innerHeight) + viewport_height = window.innerHeight; + else + viewport_height = $(window).height(); + sidebarbutton.find('span').css({ + 'display': 'block', + 'margin-top': (viewport_height - sidebar.position().top - 20) / 2 + }); + + sidebarbutton.click(toggle_sidebar); + sidebarbutton.attr('title', _('Collapse sidebar')); + sidebarbutton.css({ + 'color': '#FFFFFF', + 'border-left': '1px solid ' + dark_color, + 'font-size': '1.2em', + 'cursor': 'pointer', + 'height': bodywrapper.height(), + 'padding-top': '1px', + 'margin-left': ssb_width_expanded - 12 + }); + + sidebarbutton.hover( + function () { + $(this).css('background-color', dark_color); + }, + function () { + $(this).css('background-color', light_color); + } + ); + } + + function set_position_from_cookie() { + if (!document.cookie) + return; + var items = document.cookie.split(';'); + for(var k=0; k=e.computed&&(e={value:f,computed:g})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);var e={computed:Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;gf?1:0}),"value")};b.sortedIndex=function(a,c,d){d=d||b.identity;for(var e=0,f=a.length;e>1;d(a[g])=0})})};b.zip=function(){for(var a=b.toArray(arguments),c=b.max(b.pluck(a,"length")),d=new Array(c),e=0;e0?f-c:c-f)>=0)return e;e[g++]=f}};b.bind=function(a,c){var d=b.rest(arguments,2);return function(){return a.apply(c||j,d.concat(b.toArray(arguments)))}};b.bindAll=function(a){var c=b.rest(arguments);if(c.length==0)c=b.functions(a);b.each(c,function(d){a[d]=b.bind(a[d],a)}); +return a};b.delay=function(a,c){var d=b.rest(arguments,2);return setTimeout(function(){return a.apply(a,d)},c)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(b.rest(arguments)))};b.wrap=function(a,c){return function(){var d=[a].concat(b.toArray(arguments));return c.apply(c,d)}};b.compose=function(){var a=b.toArray(arguments);return function(){for(var c=b.toArray(arguments),d=a.length-1;d>=0;d--)c=[a[d].apply(this,c)];return c[0]}};b.keys=function(a){if(b.isArray(a))return b.range(0,a.length); +var c=[];for(var d in a)q.call(a,d)&&c.push(d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=function(a){return b.select(b.keys(a),function(c){return b.isFunction(a[c])}).sort()};b.extend=function(a,c){for(var d in c)a[d]=c[d];return a};b.clone=function(a){if(b.isArray(a))return a.slice(0);return b.extend({},a)};b.tap=function(a,c){c(a);return a};b.isEqual=function(a,c){if(a===c)return true;var d=typeof a;if(d!=typeof c)return false;if(a==c)return true;if(!a&&c||a&&!c)return false; +if(a.isEqual)return a.isEqual(c);if(b.isDate(a)&&b.isDate(c))return a.getTime()===c.getTime();if(b.isNaN(a)&&b.isNaN(c))return true;if(b.isRegExp(a)&&b.isRegExp(c))return a.source===c.source&&a.global===c.global&&a.ignoreCase===c.ignoreCase&&a.multiline===c.multiline;if(d!=="object")return false;if(a.length&&a.length!==c.length)return false;d=b.keys(a);var e=b.keys(c);if(d.length!=e.length)return false;for(var f in a)if(!b.isEqual(a[f],c[f]))return false;return true};b.isEmpty=function(a){return b.keys(a).length== +0};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=function(a){return!!(a&&a.concat&&a.unshift)};b.isArguments=function(a){return a&&b.isNumber(a.length)&&!b.isArray(a)&&!r.call(a,"length")};b.isFunction=function(a){return!!(a&&a.constructor&&a.call&&a.apply)};b.isString=function(a){return!!(a===""||a&&a.charCodeAt&&a.substr)};b.isNumber=function(a){return p.call(a)==="[object Number]"};b.isDate=function(a){return!!(a&&a.getTimezoneOffset&&a.setUTCFullYear)};b.isRegExp=function(a){return!!(a&& +a.test&&a.exec&&(a.ignoreCase||a.ignoreCase===false))};b.isNaN=function(a){return b.isNumber(a)&&isNaN(a)};b.isNull=function(a){return a===null};b.isUndefined=function(a){return typeof a=="undefined"};b.noConflict=function(){j._=n;return this};b.identity=function(a){return a};b.breakLoop=function(){throw m;};var s=0;b.uniqueId=function(a){var c=s++;return a?a+c:c};b.template=function(a,c){a=new Function("obj","var p=[],print=function(){p.push.apply(p,arguments);};with(obj){p.push('"+a.replace(/[\r\t\n]/g, +" ").replace(/'(?=[^%]*%>)/g,"\t").split("'").join("\\'").split("\t").join("'").replace(/<%=(.+?)%>/g,"',$1,'").split("<%").join("');").split("%>").join("p.push('")+"');}return p.join('');");return c?a(c):a};b.forEach=b.each;b.foldl=b.inject=b.reduce;b.foldr=b.reduceRight;b.filter=b.select;b.every=b.all;b.some=b.any;b.head=b.first;b.tail=b.rest;b.methods=b.functions;var l=function(a,c){return c?b(a).chain():a};b.each(b.functions(b),function(a){var c=b[a];i.prototype[a]=function(){var d=b.toArray(arguments); +o.call(d,this._wrapped);return l(c.apply(b,d),this._chain)}});b.each(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){c.apply(this._wrapped,arguments);return l(this._wrapped,this._chain)}});b.each(["concat","join","slice"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){return l(c.apply(this._wrapped,arguments),this._chain)}});i.prototype.chain=function(){this._chain=true;return this};i.prototype.value=function(){return this._wrapped}})(); diff --git a/doc/build/html/_static/up-pressed.png b/doc/build/html/_static/up-pressed.png new file mode 100644 index 00000000..8bd587af Binary files /dev/null and b/doc/build/html/_static/up-pressed.png differ diff --git a/doc/build/html/_static/up.png b/doc/build/html/_static/up.png new file mode 100644 index 00000000..b9462568 Binary files /dev/null and b/doc/build/html/_static/up.png differ diff --git a/doc/build/html/_static/websupport.js b/doc/build/html/_static/websupport.js new file mode 100644 index 00000000..e9bd1b85 --- /dev/null +++ b/doc/build/html/_static/websupport.js @@ -0,0 +1,808 @@ +/* + * websupport.js + * ~~~~~~~~~~~~~ + * + * sphinx.websupport utilties for all documentation. + * + * :copyright: Copyright 2007-2011 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +(function($) { + $.fn.autogrow = function() { + return this.each(function() { + var textarea = this; + + $.fn.autogrow.resize(textarea); + + $(textarea) + .focus(function() { + textarea.interval = setInterval(function() { + $.fn.autogrow.resize(textarea); + }, 500); + }) + .blur(function() { + clearInterval(textarea.interval); + }); + }); + }; + + $.fn.autogrow.resize = function(textarea) { + var lineHeight = parseInt($(textarea).css('line-height'), 10); + var lines = textarea.value.split('\n'); + var columns = textarea.cols; + var lineCount = 0; + $.each(lines, function() { + lineCount += Math.ceil(this.length / columns) || 1; + }); + var height = lineHeight * (lineCount + 1); + $(textarea).css('height', height); + }; +})(jQuery); + +(function($) { + var comp, by; + + function init() { + initEvents(); + initComparator(); + } + + function initEvents() { + $('a.comment-close').live("click", function(event) { + event.preventDefault(); + hide($(this).attr('id').substring(2)); + }); + $('a.vote').live("click", function(event) { + event.preventDefault(); + handleVote($(this)); + }); + $('a.reply').live("click", function(event) { + event.preventDefault(); + openReply($(this).attr('id').substring(2)); + }); + $('a.close-reply').live("click", function(event) { + event.preventDefault(); + closeReply($(this).attr('id').substring(2)); + }); + $('a.sort-option').live("click", function(event) { + event.preventDefault(); + handleReSort($(this)); + }); + $('a.show-proposal').live("click", function(event) { + event.preventDefault(); + showProposal($(this).attr('id').substring(2)); + }); + $('a.hide-proposal').live("click", function(event) { + event.preventDefault(); + hideProposal($(this).attr('id').substring(2)); + }); + $('a.show-propose-change').live("click", function(event) { + event.preventDefault(); + showProposeChange($(this).attr('id').substring(2)); + }); + $('a.hide-propose-change').live("click", function(event) { + event.preventDefault(); + hideProposeChange($(this).attr('id').substring(2)); + }); + $('a.accept-comment').live("click", function(event) { + event.preventDefault(); + acceptComment($(this).attr('id').substring(2)); + }); + $('a.delete-comment').live("click", function(event) { + event.preventDefault(); + deleteComment($(this).attr('id').substring(2)); + }); + $('a.comment-markup').live("click", function(event) { + event.preventDefault(); + toggleCommentMarkupBox($(this).attr('id').substring(2)); + }); + } + + /** + * Set comp, which is a comparator function used for sorting and + * inserting comments into the list. + */ + function setComparator() { + // If the first three letters are "asc", sort in ascending order + // and remove the prefix. + if (by.substring(0,3) == 'asc') { + var i = by.substring(3); + comp = function(a, b) { return a[i] - b[i]; }; + } else { + // Otherwise sort in descending order. + comp = function(a, b) { return b[by] - a[by]; }; + } + + // Reset link styles and format the selected sort option. + $('a.sel').attr('href', '#').removeClass('sel'); + $('a.by' + by).removeAttr('href').addClass('sel'); + } + + /** + * Create a comp function. If the user has preferences stored in + * the sortBy cookie, use those, otherwise use the default. + */ + function initComparator() { + by = 'rating'; // Default to sort by rating. + // If the sortBy cookie is set, use that instead. + if (document.cookie.length > 0) { + var start = document.cookie.indexOf('sortBy='); + if (start != -1) { + start = start + 7; + var end = document.cookie.indexOf(";", start); + if (end == -1) { + end = document.cookie.length; + by = unescape(document.cookie.substring(start, end)); + } + } + } + setComparator(); + } + + /** + * Show a comment div. + */ + function show(id) { + $('#ao' + id).hide(); + $('#ah' + id).show(); + var context = $.extend({id: id}, opts); + var popup = $(renderTemplate(popupTemplate, context)).hide(); + popup.find('textarea[name="proposal"]').hide(); + popup.find('a.by' + by).addClass('sel'); + var form = popup.find('#cf' + id); + form.submit(function(event) { + event.preventDefault(); + addComment(form); + }); + $('#s' + id).after(popup); + popup.slideDown('fast', function() { + getComments(id); + }); + } + + /** + * Hide a comment div. + */ + function hide(id) { + $('#ah' + id).hide(); + $('#ao' + id).show(); + var div = $('#sc' + id); + div.slideUp('fast', function() { + div.remove(); + }); + } + + /** + * Perform an ajax request to get comments for a node + * and insert the comments into the comments tree. + */ + function getComments(id) { + $.ajax({ + type: 'GET', + url: opts.getCommentsURL, + data: {node: id}, + success: function(data, textStatus, request) { + var ul = $('#cl' + id); + var speed = 100; + $('#cf' + id) + .find('textarea[name="proposal"]') + .data('source', data.source); + + if (data.comments.length === 0) { + ul.html('
  • No comments yet.
    • '); + ul.data('empty', true); + } else { + // If there are comments, sort them and put them in the list. + var comments = sortComments(data.comments); + speed = data.comments.length * 100; + appendComments(comments, ul); + ul.data('empty', false); + } + $('#cn' + id).slideUp(speed + 200); + ul.slideDown(speed); + }, + error: function(request, textStatus, error) { + showError('Oops, there was a problem retrieving the comments.'); + }, + dataType: 'json' + }); + } + + /** + * Add a comment via ajax and insert the comment into the comment tree. + */ + function addComment(form) { + var node_id = form.find('input[name="node"]').val(); + var parent_id = form.find('input[name="parent"]').val(); + var text = form.find('textarea[name="comment"]').val(); + var proposal = form.find('textarea[name="proposal"]').val(); + + if (text == '') { + showError('Please enter a comment.'); + return; + } + + // Disable the form that is being submitted. + form.find('textarea,input').attr('disabled', 'disabled'); + + // Send the comment to the server. + $.ajax({ + type: "POST", + url: opts.addCommentURL, + dataType: 'json', + data: { + node: node_id, + parent: parent_id, + text: text, + proposal: proposal + }, + success: function(data, textStatus, error) { + // Reset the form. + if (node_id) { + hideProposeChange(node_id); + } + form.find('textarea') + .val('') + .add(form.find('input')) + .removeAttr('disabled'); + var ul = $('#cl' + (node_id || parent_id)); + if (ul.data('empty')) { + $(ul).empty(); + ul.data('empty', false); + } + insertComment(data.comment); + var ao = $('#ao' + node_id); + ao.find('img').attr({'src': opts.commentBrightImage}); + if (node_id) { + // if this was a "root" comment, remove the commenting box + // (the user can get it back by reopening the comment popup) + $('#ca' + node_id).slideUp(); + } + }, + error: function(request, textStatus, error) { + form.find('textarea,input').removeAttr('disabled'); + showError('Oops, there was a problem adding the comment.'); + } + }); + } + + /** + * Recursively append comments to the main comment list and children + * lists, creating the comment tree. + */ + function appendComments(comments, ul) { + $.each(comments, function() { + var div = createCommentDiv(this); + ul.append($(document.createElement('li')).html(div)); + appendComments(this.children, div.find('ul.comment-children')); + // To avoid stagnating data, don't store the comments children in data. + this.children = null; + div.data('comment', this); + }); + } + + /** + * After adding a new comment, it must be inserted in the correct + * location in the comment tree. + */ + function insertComment(comment) { + var div = createCommentDiv(comment); + + // To avoid stagnating data, don't store the comments children in data. + comment.children = null; + div.data('comment', comment); + + var ul = $('#cl' + (comment.node || comment.parent)); + var siblings = getChildren(ul); + + var li = $(document.createElement('li')); + li.hide(); + + // Determine where in the parents children list to insert this comment. + for(i=0; i < siblings.length; i++) { + if (comp(comment, siblings[i]) <= 0) { + $('#cd' + siblings[i].id) + .parent() + .before(li.html(div)); + li.slideDown('fast'); + return; + } + } + + // If we get here, this comment rates lower than all the others, + // or it is the only comment in the list. + ul.append(li.html(div)); + li.slideDown('fast'); + } + + function acceptComment(id) { + $.ajax({ + type: 'POST', + url: opts.acceptCommentURL, + data: {id: id}, + success: function(data, textStatus, request) { + $('#cm' + id).fadeOut('fast'); + $('#cd' + id).removeClass('moderate'); + }, + error: function(request, textStatus, error) { + showError('Oops, there was a problem accepting the comment.'); + } + }); + } + + function deleteComment(id) { + $.ajax({ + type: 'POST', + url: opts.deleteCommentURL, + data: {id: id}, + success: function(data, textStatus, request) { + var div = $('#cd' + id); + if (data == 'delete') { + // Moderator mode: remove the comment and all children immediately + div.slideUp('fast', function() { + div.remove(); + }); + return; + } + // User mode: only mark the comment as deleted + div + .find('span.user-id:first') + .text('[deleted]').end() + .find('div.comment-text:first') + .text('[deleted]').end() + .find('#cm' + id + ', #dc' + id + ', #ac' + id + ', #rc' + id + + ', #sp' + id + ', #hp' + id + ', #cr' + id + ', #rl' + id) + .remove(); + var comment = div.data('comment'); + comment.username = '[deleted]'; + comment.text = '[deleted]'; + div.data('comment', comment); + }, + error: function(request, textStatus, error) { + showError('Oops, there was a problem deleting the comment.'); + } + }); + } + + function showProposal(id) { + $('#sp' + id).hide(); + $('#hp' + id).show(); + $('#pr' + id).slideDown('fast'); + } + + function hideProposal(id) { + $('#hp' + id).hide(); + $('#sp' + id).show(); + $('#pr' + id).slideUp('fast'); + } + + function showProposeChange(id) { + $('#pc' + id).hide(); + $('#hc' + id).show(); + var textarea = $('#pt' + id); + textarea.val(textarea.data('source')); + $.fn.autogrow.resize(textarea[0]); + textarea.slideDown('fast'); + } + + function hideProposeChange(id) { + $('#hc' + id).hide(); + $('#pc' + id).show(); + var textarea = $('#pt' + id); + textarea.val('').removeAttr('disabled'); + textarea.slideUp('fast'); + } + + function toggleCommentMarkupBox(id) { + $('#mb' + id).toggle(); + } + + /** Handle when the user clicks on a sort by link. */ + function handleReSort(link) { + var classes = link.attr('class').split(/\s+/); + for (var i=0; iThank you! Your comment will show up ' + + 'once it is has been approved by a moderator.'); + } + // Prettify the comment rating. + comment.pretty_rating = comment.rating + ' point' + + (comment.rating == 1 ? '' : 's'); + // Make a class (for displaying not yet moderated comments differently) + comment.css_class = comment.displayed ? '' : ' moderate'; + // Create a div for this comment. + var context = $.extend({}, opts, comment); + var div = $(renderTemplate(commentTemplate, context)); + + // If the user has voted on this comment, highlight the correct arrow. + if (comment.vote) { + var direction = (comment.vote == 1) ? 'u' : 'd'; + div.find('#' + direction + 'v' + comment.id).hide(); + div.find('#' + direction + 'u' + comment.id).show(); + } + + if (opts.moderator || comment.text != '[deleted]') { + div.find('a.reply').show(); + if (comment.proposal_diff) + div.find('#sp' + comment.id).show(); + if (opts.moderator && !comment.displayed) + div.find('#cm' + comment.id).show(); + if (opts.moderator || (opts.username == comment.username)) + div.find('#dc' + comment.id).show(); + } + return div; + } + + /** + * A simple template renderer. Placeholders such as <%id%> are replaced + * by context['id'] with items being escaped. Placeholders such as <#id#> + * are not escaped. + */ + function renderTemplate(template, context) { + var esc = $(document.createElement('div')); + + function handle(ph, escape) { + var cur = context; + $.each(ph.split('.'), function() { + cur = cur[this]; + }); + return escape ? esc.text(cur || "").html() : cur; + } + + return template.replace(/<([%#])([\w\.]*)\1>/g, function() { + return handle(arguments[2], arguments[1] == '%' ? true : false); + }); + } + + /** Flash an error message briefly. */ + function showError(message) { + $(document.createElement('div')).attr({'class': 'popup-error'}) + .append($(document.createElement('div')) + .attr({'class': 'error-message'}).text(message)) + .appendTo('body') + .fadeIn("slow") + .delay(2000) + .fadeOut("slow"); + } + + /** Add a link the user uses to open the comments popup. */ + $.fn.comment = function() { + return this.each(function() { + var id = $(this).attr('id').substring(1); + var count = COMMENT_METADATA[id]; + var title = count + ' comment' + (count == 1 ? '' : 's'); + var image = count > 0 ? opts.commentBrightImage : opts.commentImage; + var addcls = count == 0 ? ' nocomment' : ''; + $(this) + .append( + $(document.createElement('a')).attr({ + href: '#', + 'class': 'sphinx-comment-open' + addcls, + id: 'ao' + id + }) + .append($(document.createElement('img')).attr({ + src: image, + alt: 'comment', + title: title + })) + .click(function(event) { + event.preventDefault(); + show($(this).attr('id').substring(2)); + }) + ) + .append( + $(document.createElement('a')).attr({ + href: '#', + 'class': 'sphinx-comment-close hidden', + id: 'ah' + id + }) + .append($(document.createElement('img')).attr({ + src: opts.closeCommentImage, + alt: 'close', + title: 'close' + })) + .click(function(event) { + event.preventDefault(); + hide($(this).attr('id').substring(2)); + }) + ); + }); + }; + + var opts = { + processVoteURL: '/_process_vote', + addCommentURL: '/_add_comment', + getCommentsURL: '/_get_comments', + acceptCommentURL: '/_accept_comment', + deleteCommentURL: '/_delete_comment', + commentImage: '/static/_static/comment.png', + closeCommentImage: '/static/_static/comment-close.png', + loadingImage: '/static/_static/ajax-loader.gif', + commentBrightImage: '/static/_static/comment-bright.png', + upArrow: '/static/_static/up.png', + downArrow: '/static/_static/down.png', + upArrowPressed: '/static/_static/up-pressed.png', + downArrowPressed: '/static/_static/down-pressed.png', + voting: false, + moderator: false + }; + + if (typeof COMMENT_OPTIONS != "undefined") { + opts = jQuery.extend(opts, COMMENT_OPTIONS); + } + + var popupTemplate = '\ +
    \ +

    \ + Sort by:\ + best rated\ + newest\ + oldest\ +

    \ +
    Comments
    \ +
    \ + loading comments...
    \ +
      \ +
      \ +

      Add a comment\ + (markup):

      \ +
      \ + reStructured text markup: *emph*, **strong**, \ + ``code``, \ + code blocks: :: and an indented block after blank line
      \ +
      \ + \ +

      \ + \ + Propose a change ▹\ + \ + \ + Propose a change ▿\ + \ +

      \ + \ + \ + \ + \ +
      \ +
      \ +
      '; + + var commentTemplate = '\ +
      \ +
      \ +
      \ + \ + \ + \ + \ + \ + \ +
      \ +
      \ + \ + \ + \ + \ + \ + \ +
      \ +
      \ +
      \ +

      \ + <%username%>\ + <%pretty_rating%>\ + <%time.delta%>\ +

      \ +
      <#text#>
      \ +

      \ + \ + reply ▿\ + proposal ▹\ + proposal ▿\ + \ + \ +

      \ + 
      \
+<#proposal_diff#>\
+
      \ +
        \ +
        \ +
        \ +
        \ + '; + + var replyTemplate = '\ +
      • \ +
        \ +
        \ + \ + \ + \ + \ + \ +
        \ +
        \ +
        • '; + + $(document).ready(function() { + init(); + }); +})(jQuery); + +$(document).ready(function() { + // add comment anchors for all paragraphs that are commentable + $('.sphinx-has-comment').comment(); + + // highlight search words in search results + $("div.context").each(function() { + var params = $.getQueryParameters(); + var terms = (params.q) ? params.q[0].split(/\s+/) : []; + var result = $(this); + $.each(terms, function() { + result.highlightText(this.toLowerCase(), 'highlighted'); + }); + }); + + // directly open comment window if requested + var anchor = document.location.hash; + if (anchor.substring(0, 9) == '#comment-') { + $('#ao' + anchor.substring(9)).click(); + document.location.hash = '#s' + anchor.substring(9); + } +}); diff --git a/doc/build/html/genindex.html b/doc/build/html/genindex.html new file mode 100644 index 00000000..02ef5706 --- /dev/null +++ b/doc/build/html/genindex.html @@ -0,0 +1,415 @@ + + + + + + + + + + + + Index — python-flint 0.1 documentation + + + + + + + + + + + + +
        +

        Navigation

        + +
        + +
        +
        +
        +
        + + +

        Index

        + +
        + C + | D + | E + | F + | L + | M + | N + | P + | Q + | R + | T + +
        +

        C

        + + +
        + +
        coeffs() (flint.fmpq_poly method) +
        + +
        + +
        (flint.fmpz_poly method) +
        + + +
        (flint.nmod_poly method) +
        + +
        +
        + +

        D

        + + + +
        + +
        degree() (flint.fmpq_poly method) +
        + +
        + +
        (flint.fmpz_poly method) +
        + + +
        (flint.nmod_poly method) +
        + +
        + +
        denom() (flint.fmpq method) +
        + +
        + +
        (flint.fmpq_poly method) +
        + +
        +
        + +
        det() (flint.fmpq_mat method) +
        + +
        + +
        (flint.fmpz_mat method) +
        + + +
        (flint.nmod_mat method) +
        + +
        +
        + +

        E

        + + +
        + +
        entries() (flint.fmpq_mat method) +
        + +
        + +
        (flint.fmpz_mat method) +
        + + +
        (flint.nmod_mat method) +
        + +
        +
        + +

        F

        + + + +
        + +
        fmpq (class in flint) +
        + + +
        fmpq_mat (class in flint) +
        + + +
        fmpq_poly (class in flint) +
        + +
        + +
        fmpz (class in flint) +
        + + +
        fmpz_mat (class in flint) +
        + + +
        fmpz_poly (class in flint) +
        + +
        + +

        L

        + + +
        + +
        length() (flint.fmpq_poly method) +
        + +
        + +
        (flint.fmpz_poly method) +
        + + +
        (flint.nmod_poly method) +
        + +
        +
        + +

        M

        + + +
        + +
        modulus() (flint.nmod method) +
        + +
        + +
        (flint.nmod_mat method) +
        + + +
        (flint.nmod_poly method) +
        + +
        +
        + +

        N

        + + + +
        + +
        ncols() (flint.fmpq_mat method) +
        + +
        + +
        (flint.fmpz_mat method) +
        + + +
        (flint.nmod_mat method) +
        + +
        + +
        nmod (class in flint) +
        + + +
        nmod_mat (class in flint) +
        + + +
        nmod_poly (class in flint) +
        + +
        + +
        nrows() (flint.fmpq_mat method) +
        + +
        + +
        (flint.fmpz_mat method) +
        + + +
        (flint.nmod_mat method) +
        + +
        + +
        number_of_partitions() (in module flint) +
        + + +
        numer() (flint.fmpq method) +
        + +
        + +
        (flint.fmpq_poly method) +
        + +
        +
        + +

        P

        + + +
        + +
        p (flint.fmpq attribute) +
        + +
        + +
        (flint.fmpq_poly attribute) +
        + +
        +
        + +

        Q

        + + +
        + +
        q (flint.fmpq attribute) +
        + +
        + +
        (flint.fmpq_poly attribute) +
        + +
        +
        + +

        R

        + + + +
        + +
        randbits() (flint.fmpz_mat static method) +
        + + +
        randrank() (flint.fmpz_mat static method) +
        + +
        + +
        randtest() (flint.fmpz_mat static method) +
        + +
        + +
        (flint.nmod_mat static method) +
        + +
        + +
        rank() (flint.fmpz_mat method) +
        + +
        + +
        (flint.nmod_mat method) +
        + +
        +
        + +

        T

        + + +
        + +
        table() (flint.fmpq_mat method) +
        + +
        + +
        (flint.fmpz_mat method) +
        + + +
        (flint.nmod_mat method) +
        + +
        +
        + + + +
        +
        +
        +
        +
        + + + + + +
        +
        +
        +
        +
        +

        Navigation

        + +
        +
        + © Copyright 2012, Fredrik Johansson. + Created using Sphinx 1.1.3. +
        + + \ No newline at end of file diff --git a/doc/build/html/index.html b/doc/build/html/index.html new file mode 100644 index 00000000..f078e9bf --- /dev/null +++ b/doc/build/html/index.html @@ -0,0 +1,667 @@ + + + + + + + + + + Python bindings for FLINT — python-flint 0.1 documentation + + + + + + + + + + + + +
        +

        Navigation

        + +
        + +
        +
        +
        +
        + +
        +

        Python bindings for FLINT

        +
        +

        Introduction

        +

        The python-flint Python extension module provides +bindings to FLINT (http://flintlib.org/). +FLINT (Fast Library for Number Theory) is a C library that implements +highly optimised exact scalar, polynomial and matrix arithmetic as +well as many number-theoretic special functions.

        +

        As of the current version, only a subset of the FLINT types +are wrapped, and only a very limited selection of methods are provided. +There are known and unknown bugs, and the interface is subject to +change drastically in the future. Any feedback is welcome +and can be sent to fredrik.johansson@gmail.com or flint-devel@googlegroups.com. +Of particular note:

        +
          +
        • Most functionality in FLINT is not yet wrapped!
          • +
        • Coercions are not supported in all directions.
          • +
        • Conversion between Python longs and fmpzs is not done efficiently.
          • +
        • Types don’t yet provide hash methods.
          • +
        • Interaction with gmpy (http://gmpy.org/) types (and types from many other libraries) is not supported.
          • +
        +
        +
        +

        Setup

        +

        To build this module, you first need to install the latest +version of FLINT (follow the instructions in the FLINT documentation). You +also need to install Cython (http://cython.org/).

        +

        Next, extract the python-flint archive and run:

        +
        python ./setup.py build_ext
+sudo python ./setup.py install
+python ./test.py
        +
        +

        Note: if FLINT is not installed globally, you can do something like the following (the second +line is required for loading FLINT from Python):

        +
        python ./setup.py build_ext --include-dirs=/home/fredrik/src/flint2 --library-dirs=/home/fredrik/src/flint2
+export LD_LIBRARY_PATH=/home/fredrik/src/flint2/:$LD_LIBRARY_PATH
        +
        +

        If everything worked, you will be able to import the flint module +in Python:

        +
        Python 2.7.3 (default, Apr 20 2012, 22:39:59)
+[GCC 4.6.3] on linux2
+Type "help", "copyright", "credits" or "license" for more information.
+>>> import flint
+>>> flint.fmpz(33) ** 33
+fmpz(129110040087761027839616029934664535539337183380513)
        +
        +
        +
        +

        Reference

        +
        +

        Scalar types

        +
        +

        fmpz

        +
        +
        +class flint.fmpz
        +

        fmpz(val=None)

        +

        The fmpz type represents multiprecision integers.

        +
        >>> fmpz(3) ** 25
+fmpz(847288609443)
+
        +
        +
        + +
        +
        +

        fmpq

        +
        +
        +class flint.fmpq
        +

        fmpq(p=None, q=None)

        +

        The fmpq type represents multiprecision rational numbers.

        +
        >>> fmpq(1,7) + fmpq(50,51)
+fmpq(401,357)
+
        +
        +
        +
        +denom(self)
        +
        + +
        +
        +numer(self)
        +
        + +
        +
        +p
        +

        fmpq.numer(self)

        +
        + +
        +
        +q
        +

        fmpq.denom(self)

        +
        + +
        + +
        +
        +

        nmod

        +
        +
        +class flint.nmod
        +

        nmod(val, mod)

        +

        The nmod type represents elements of Z/nZ for word-size n.

        +
        >>> nmod(10,17) * 2
+nmod(3, 17)
+
        +
        +
        +
        +modulus(self)
        +
        + +
        + +
        +
        +
        +

        Polynomial types

        +
        +

        fmpz_poly

        +
        +
        +class flint.fmpz_poly
        +

        fmpz_poly(val=None)

        +

        The fmpz_poly type represents dense univariate polynomials over +the integers.

        +
        >>> fmpz_poly([1,2,3]) ** 3
+fmpz_poly([1, 6, 21, 44, 63, 54, 27])
+>>> divmod(fmpz_poly([2,0,1,1,6]), fmpz_poly([3,5,7]))
+(fmpz_poly([]), fmpz_poly([2, 0, 1, 1, 6]))
+
        +
        +
        +
        +coeffs(self)
        +
        + +
        +
        +degree(self) → long
        +
        + +
        +
        +length(self) → long
        +
        + +
        + +
        +
        +

        fmpq_poly

        +
        +
        +class flint.fmpq_poly
        +

        fmpq_poly(p=None, q=None)

        +

        The fmpq_poly type represents dense univariate polynomials +over the rational numbers. For efficiency reasons, an fmpq_poly is +structurally an integer polynomial with a single common denominator.

        +
        >>> fmpq_poly([1,2,3],5) ** 3
+fmpq_poly([1, 6, 21, 44, 63, 54, 27], 125)
+>>> print _
+27/125*x^6 + 54/125*x^5 + 63/125*x^4 + 44/125*x^3 + 21/125*x^2 + 6/125*x + 1/125
+>>> divmod(fmpq_poly([2,0,1,1,6]), fmpq_poly([3,5,7]))
+(fmpq_poly([38, -161, 294], 343), fmpq_poly([572, 293, 0, 0, 0], 343))
+
        +
        +
        +
        +coeffs(self)
        +
        + +
        +
        +degree(self) → long
        +
        + +
        +
        +denom(self)
        +
        + +
        +
        +length(self) → long
        +
        + +
        +
        +numer(self)
        +
        + +
        +
        +p
        +

        fmpq_poly.numer(self)

        +
        + +
        +
        +q
        +

        fmpq_poly.denom(self)

        +
        + +
        + +
        +
        +

        nmod_poly

        +
        +
        +class flint.nmod_poly
        +

        nmod_poly(val=None, ulong mod=0)

        +

        The nmod_poly type represents dense univariate polynomials +over Z/nZ for word-size n.

        +
        >>> a = nmod_poly([5,1,10,14,8], 7)
+>>> print a
+x^4+3*x^2+x+5
+>>> print -a
+6*x^4+4*x^2+6*x+2
+>>> list(nmod_poly(range(3), 2))
+[nmod(0, 2), nmod(1, 2)]
+>>> nmod_poly([1, 2, 3], 23) ** 3
+nmod_poly([1L, 6L, 21L, 21L, 17L, 8L, 4L], 23)
+>>> divmod(nmod_poly([2,0,1,1,6],23), nmod_poly([3,5,7],23))
+(nmod_poly([4L, 0L, 14L], 23), nmod_poly([13L, 3L], 23))
+
        +
        +
        +
        +coeffs(self)
        +
        + +
        +
        +degree(self) → long
        +
        + +
        +
        +length(self) → long
        +
        + +
        +
        +modulus(self) → mp_limb_t
        +
        + +
        + +
        +
        +
        +

        Matrix types

        +
        +

        fmpz_mat

        +
        +
        +class flint.fmpz_mat
        +

        The fmpz_mat type represents dense matrices over the integers.

        +

        An fmpz_mat can be constructed empty, from a list of entries +in row-major order, or from an existing matrix:

        +
        >>> fmpz_mat(2, 4)
+fmpz_mat(2, 4, [0, 0, 0, 0, 0, 0, 0, 0])
+>>> A = fmpz_mat(2, 4, range(8))
+>>> print(A)
+[0, 1, 2, 3]
+[4, 5, 6, 7]
+>>> fmpz_mat(A) == A
+True
+
        +
        +

        Entries can be accessed and set:

        +
        >>> A[0,1]
+fmpz(1)
+>>> A[1,3] = 8
+>>> A
+fmpz_mat(2, 4, [0, 1, 2, 3, 4, 5, 6, 8])
+
        +
        +

        Arithmetic operations are supported:

        +
        >>> A * 3
+fmpz_mat(2, 4, [0, 3, 6, 9, 12, 15, 18, 24])
+>>> A + (-A)
+fmpz_mat(2, 4, [0, 0, 0, 0, 0, 0, 0, 0])
+>>> A * fmpz_mat(4, 3, range(12))
+fmpz_mat(2, 3, [42, 48, 54, 123, 146, 169])
+>>> A * fmpz_mat(3, 3, range(9))
+Traceback (most recent call last):
+  ...
+ValueError: incompatible shapes for matrix multiplication
+
        +
        +

        The ~ operator returns the inverse of the matrix, which will +be of type fmpq_mat:

        +
        >>> print(~fmpz_mat(3,3,[1,2,4,0,1,1,2,-1,0]))
+[-1/3,  4/3,  2/3]
+[-2/3,  8/3,  1/3]
+[ 2/3, -5/3, -1/3]
+
        +
        +
        +
        +det(self)
        +

        Returns the determinant of self as an fmpz.

        +
        >>> A = fmpz_mat(3, 3, range(9))
+>>> A.det()
+fmpz(0)
+>>> A[2,2] = 10
+>>> A.det()
+fmpz(-6)
+>>> (A * A).det()
+fmpz(36)
+>>> fmpz_mat(0, 0).det()
+fmpz(1)
+
        +
        +
        + +
        +
        +entries(self)
        +

        Returns self as a flat list of fmpz entries, +output in row-major order.

        +
        >>> A = fmpz_mat(2, 4, range(8))
+>>> A.entries()
+[fmpz(0), fmpz(1), fmpz(2), fmpz(3), fmpz(4), fmpz(5), fmpz(6), fmpz(7)]
+
        +
        +
        + +
        +
        +ncols(self) → long
        +

        Returns the number of columns of self.

        +
        + +
        +
        +nrows(self) → long
        +

        Returns the number of rows of self.

        +
        + +
        +
        +static randbits(type cls, ulong m, ulong n, ulong bits)
        +

        Returns a random (m, n) matrix with uniformly chosen entries up +to the specified number of bits in size.

        +
        >>> print(fmpz_mat.randbits(3, 2, 100))   
+[  502804798116524380422349115480, -93136769489619409388141424916]
+[-1201505897735399116254292047234, 145439343004100224514654363320]
+[ 1183889243483733739229662952032, 632771515833349927306121868518]
+
        +
        +
        + +
        +
        +static randrank(type cls, ulong m, ulong n, ulong rank, ulong bits)
        +

        Returns a random sparse (m, n) matrix of the specified rank +with entries up to the specified number of bits in size.

        +
        >>> print(flint.fmpz_mat.randrank(3,6,2,20))   
+[0, 484749, 0, 0, 0,     0]
+[0,      0, 0, 0, 0,     0]
+[0,      0, 0, 0, 0, -2048]
+
        +
        +
        + +
        +
        +static randtest(type cls, ulong m, ulong n, ulong bits)
        +

        Returns a random (m, n) matrix with non-uniformly chosen +entries up to the specified number of bits in size. Small and +zero entries are generated with increased probability.

        +
        >>> print(fmpz_mat.randtest(3, 2, 100))   
+[        5442103460568216, 1906839377153448]
+[-37778931862922801979391,                0]
+[                       0,                1]
+
        +
        +
        + +
        +
        +rank(self)
        +

        Returns the rank of self.

        +
        >>> A = fmpz_mat(3, 3, range(9))
+>>> A.rank()
+2
+>>> A[2,2] = 10
+>>> A.rank()
+3
+
        +
        +
        + +
        +
        +table(self)
        +

        Returns self as a nested list of fmpz entries, +output in row-major order.

        +
        >>> A = fmpz_mat(2, 4, range(8))
+>>> A.table()
+[[fmpz(0), fmpz(1), fmpz(2), fmpz(3)], [fmpz(4), fmpz(5), fmpz(6), fmpz(7)]]
+
        +
        +
        + +
        + +
        +
        +

        fmpq_mat

        +
        +
        +class flint.fmpq_mat
        +

        The fmpq_mat type represents dense matrices over the rational +numbers.

        +
        >>> A = fmpq_mat(3,3,[1,3,5,2,4,6,fmpq(2,3),2,4])
+>>> print (~A)
+[-3/1,  3/2,  3/2]
+[ 3/1, -1/2, -3/1]
+[-1/1,  0/1,  3/2]
+>>> print (~A) * A
+[1/1, 0/1, 0/1]
+[0/1, 1/1, 0/1]
+[0/1, 0/1, 1/1]
+
        +
        +
        +
        +det(self)
        +

        Returns the determinant of self as an fmpq.

        +
        >>> (fmpq_mat(2,2,[1,2,3,4]) / 5).det()
+fmpq(-2,25)
+
        +
        +
        + +
        +
        +entries(self)
        +
        + +
        +
        +ncols(self) → long
        +
        + +
        +
        +nrows(self) → long
        +
        + +
        +
        +table(self)
        +
        + +
        + +
        +
        +

        nmod_mat

        +
        +
        +class flint.nmod_mat
        +

        The nmod_poly type represents dense matrices over Z/nZ for +word-size n. Some operations may assume that n is a prime.

        +
        +
        +det(self)
        +

        Returns the determinant of self as an nmod.

        +
        >>> nmod_mat(2,2,[1,2,3,4],17).det()
+nmod(15, 17)
+
        +
        +
        + +
        +
        +entries(self)
        +
        + +
        +
        +modulus(self) → mp_limb_t
        +
        + +
        +
        +ncols(self) → long
        +
        + +
        +
        +nrows(self) → long
        +
        + +
        +
        +static randtest(type cls, ulong m, ulong n, ulong mod)
        +

        Returns a random (m, n) matrix with non-uniformly chosen +entries. Zero entries are generated with increased probability.

        +
        + +
        +
        +rank(self)
        +
        + +
        +
        +table(self)
        +
        + +
        + +
        +
        +
        +

        Special functions

        +
        +
        +flint.number_of_partitions(ulong n)
        +

        Returns p(n), the number of partitions of the integer n, as an fmpz.

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

        Table Of Contents

        + + +

        This Page

        + + + +
        +
        +
        +
        +
        +

        Navigation

        + +
        +
        + © Copyright 2012, Fredrik Johansson. + Created using Sphinx 1.1.3. +
        + + \ No newline at end of file diff --git a/doc/build/html/objects.inv b/doc/build/html/objects.inv new file mode 100644 index 00000000..ef989f31 Binary files /dev/null and b/doc/build/html/objects.inv differ diff --git a/doc/build/html/py-modindex.html b/doc/build/html/py-modindex.html new file mode 100644 index 00000000..5e9c6080 --- /dev/null +++ b/doc/build/html/py-modindex.html @@ -0,0 +1,115 @@ + + + + + + + + + + Python Module Index — python-flint 0.1 documentation + + + + + + + + + + + + + + + + + +
        +

        Navigation

        + +
        + +
        +
        +
        +
        + + +

        Python Module Index

        + +
        + f +
        + + + + + + + +
         
        + f
        + flint +
        + + +
        +
        +
        +
        +
        + + +
        +
        +
        +
        +
        +

        Navigation

        + +
        +
        + © Copyright 2012, Fredrik Johansson. + Created using Sphinx 1.1.3. +
        + + \ No newline at end of file diff --git a/doc/build/html/search.html b/doc/build/html/search.html new file mode 100644 index 00000000..a30e5569 --- /dev/null +++ b/doc/build/html/search.html @@ -0,0 +1,100 @@ + + + + + + + + + + Search — python-flint 0.1 documentation + + + + + + + + + + + + + + + + +
        +

        Navigation

        + +
        + +
        +
        +
        +
        + +

        Search

        +
        + +

        + Please activate JavaScript to enable the search + functionality. +

        +
        +

        + From here you can search these documents. Enter your search + words into the box below and click "search". Note that the search + function will automatically search for all of the words. Pages + containing fewer words won't appear in the result list. +

        +
        + + + +
        + +
        + +
        + +
        +
        +
        +
        +
        +
        +
        +
        +
        +
        +

        Navigation

        + +
        +
        + © Copyright 2012, Fredrik Johansson. + Created using Sphinx 1.1.3. +
        + + \ No newline at end of file diff --git a/doc/build/html/searchindex.js b/doc/build/html/searchindex.js new file mode 100644 index 00000000..8e30245b --- /dev/null +++ b/doc/build/html/searchindex.js @@ -0,0 +1 @@ +Search.setIndex({objects:{"flint.fmpq":{numer:[0,2,1,""],q:[0,3,1,""],denom:[0,2,1,""],p:[0,3,1,""]},"flint.fmpz_poly":{coeffs:[0,2,1,""],length:[0,2,1,""],degree:[0,2,1,""]},"flint.fmpq_poly":{degree:[0,2,1,""],numer:[0,2,1,""],q:[0,3,1,""],p:[0,3,1,""],length:[0,2,1,""],denom:[0,2,1,""],coeffs:[0,2,1,""]},"flint.fmpq_mat":{nrows:[0,2,1,""],table:[0,2,1,""],det:[0,2,1,""],ncols:[0,2,1,""],entries:[0,2,1,""]},"flint.fmpz_mat":{randbits:[0,0,1,""],ncols:[0,2,1,""],randrank:[0,0,1,""],det:[0,2,1,""],rank:[0,2,1,""],nrows:[0,2,1,""],randtest:[0,0,1,""],entries:[0,2,1,""],table:[0,2,1,""]},"flint.nmod_mat":{ncols:[0,2,1,""],det:[0,2,1,""],rank:[0,2,1,""],nrows:[0,2,1,""],randtest:[0,0,1,""],entries:[0,2,1,""],table:[0,2,1,""],modulus:[0,2,1,""]},"flint.nmod_poly":{coeffs:[0,2,1,""],length:[0,2,1,""],modulus:[0,2,1,""],degree:[0,2,1,""]},flint:{fmpz_mat:[0,1,1,""],fmpz_poly:[0,1,1,""],nmod:[0,1,1,""],number_of_partitions:[0,4,1,""],fmpq_mat:[0,1,1,""],fmpq:[0,1,1,""],fmpq_poly:[0,1,1,""],fmpz:[0,1,1,""],nmod_poly:[0,1,1,""],nmod_mat:[0,1,1,""]},"flint.nmod":{modulus:[0,2,1,""]}},terms:{load:0,all:0,code:[],number_of_partit:0,feedback:0,librari:0,skip:0,over:0,random:0,major:0,veri:0,scalar:0,capsul:[],"__rdiv__":[],"__rmul__":[],follow:0,"__lt__":[],fredrik:0,"21l":0,help:0,whose:[],onli:0,copyright:0,also:0,chosen:0,"true":0,send:[],matrix_to_str:[],denomin:0,str:0,introduct:0,"__str__":[],sent:0,build:0,non:0,global:0,"return":0,"__getitem__":[],python:0,googlegroup:0,repr:[],initi:[],devel:0,test:0,flint:0,"__gt__":[],increas:0,bit:0,exact:0,requir:0,mod:0,prime:0,"__delitem__":[],"__nonzero__":[],like:0,list:0,shape:0,integ:0,"default":0,common:0,flintlib:0,small:0,output:0,page:[],dir:0,subset:0,www:[],set:0,modulo:[],signatur:[],some:0,direct:0,"__truediv__":[],"static":0,structur:0,arg:[],home:0,extract:0,modulu:0,gmail:0,index:[],matrix:0,goe:[],assum:0,someth:0,abl:0,uniform:[],content:[],fmpq:0,version:0,between:0,print:0,fmpz:0,row:0,method:0,matric:0,refer:0,"__ne__":[],spars:0,run:0,partit:0,cython:0,numer:0,gener:0,ration:0,subject:0,fast:0,len:0,extens:0,reason:0,theori:0,element:0,org:0,nmod_mat:0,ncol:0,src:0,convert:[],"0x2322b10":[],last:0,convers:0,fmpq_poli:0,randtest:0,column:0,nmod_poli:0,current:0,"__setitem__":[],fmpq_mat:0,length:0,"__repr__":[],mp_limb_t:0,randbit:0,implement:0,com:0,interact:0,first:0,oper:0,rang:0,effici:0,"__add__":[],flint2:0,apr:0,modul:0,flintpython:[],number:0,rank:0,instruct:0,"__rtruediv__":[],"__rsub__":[],divmod:0,wrap:0,"import":0,theoret:0,coercion:0,build_ext:0,select:0,size:0,given:[],done:0,from:0,val:0,mpfr:[],unknown:0,licens:0,support:0,invers:0,empti:0,next:0,call:0,includ:0,interfac:0,recent:0,instal:0,valueerror:0,more:0,"function":0,flat:0,setup:0,"17l":0,"__invert__":[],mani:0,search:[],specifi:0,ani:0,"export":0,see:[],particular:0,known:0,line:0,repres:0,"__eq__":[],bug:0,wrapper:[],johansson:0,word:0,"class":0,provid:0,type:0,coeff:0,access:0,det:0,second:0,nmod:0,"__init__":[],"__le__":[],del:[],can:0,none:0,bind:0,report:[],"__sub__":[],multiprecis:0,fmpz_poli:0,"__ge__":[],most:0,linux2:0,traceback:0,hash:0,sudo:0,"0x3b2e930":[],indic:[],"__radd__":[],univari:0,mpir:[],archiv:0,exist:0,tabl:0,need:0,limit:0,"14l":0,work:0,yet:0,optimis:0,probabl:0,gcc:0,incompat:0,multipl:0,"__new__":[],zero:0,credit:0,self:0,highli:0,degre:0,note:0,"__pos__":[],other:0,futur:0,which:0,denom:0,"new":[],you:0,document:0,singl:0,doctest:0,gmpy:0,http:0,determin:0,ulong:0,nest:0,object:[],"null":[],"long":0,polynomi:0,"__pyx_vtable__":[],arithmet:0,mai:0,drastic:0,construct:0,"13l":0,uniformli:0,chang:0,welcom:0,don:0,special:0,nrow:0,randrank:0,dens:0,entri:0,well:0,ld_library_path:0,inform:0,"__div__":[],"__mul__":[],"__neg__":[],thi:0,subtyp:[],everyth:0,fmpz_mat:0,order:0,latest:0},objtypes:{"0":"py:staticmethod","1":"py:class","2":"py:method","3":"py:attribute","4":"py:function"},titles:["Python bindings for FLINT"],objnames:{"0":["py","staticmethod","Python static method"],"1":["py","class","Python class"],"2":["py","method","Python method"],"3":["py","attribute","Python attribute"],"4":["py","function","Python function"]},filenames:["index"]}) \ No newline at end of file diff --git a/doc/source/_gr.rst b/doc/source/_gr.rst deleted file mode 100644 index 11ad72a9..00000000 --- a/doc/source/_gr.rst +++ /dev/null @@ -1,155 +0,0 @@ -**_gr** -- generic rings (unstable interface) -=============================================================================== - -.. note:: - This module provides a preliminary experimental interface for FLINT's - generic rings. This is largely untested and the interface should be - considered unstable. In future the generic rings code will be integrated - with the rest of python-flint and this module may be removed. For now it - provides access to many FLINT types that are not wrapped yet in the rest of - python-flint. - -The generic rings module provides access to the generic rings interface in -FLINT. Usage of this interface consists of creating a context object to -represent a particular domain and then using that context object to create -elements of that domain. For example to create a context for polynomials in two -variables over the Gaussian integers :math:`\mathbb{Z}[i][x,y]` we would do:: - - >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx - >>> ctx = gr_gr_mpoly_ctx.new(gr_fmpzi_ctx, ["x", "y"]) - >>> ctx.gens() - [x, y] - - # XXX: gens_recursive not available in FLINT < 3.1 - # >>> ctx.gens_recursive() - # [I, x, y] - # >>> I, x, y = ctx.gens_recursive() - - >>> x, y = ctx.gens() - >>> p = (x + y)**2 - >>> p - x^2 + 2*x*y + y^2 - -Some domains such as ``gr_fmpzi_ctx`` are global and do not need to be created. -Others such as ``gr_gr_mpoly_ctx`` are created using :meth:`gr_ctx.new`. - -.. autoclass :: flint.types._gr.gr_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_scalar_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_poly_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_mpoly_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr._gr_fmpz_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr._gr_fmpq_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr._gr_fmpzi_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr._gr_fexpr_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_nmod_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_fmpz_mod_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_fq_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_fq_nmod_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_fq_zech_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_nf_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_nf_fmpz_poly_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_real_qqbar_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_complex_qqbar_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_real_ca_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_complex_ca_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_real_algebraic_ca_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_complex_algebraic_ca_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_complex_extended_ca_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_real_float_arf_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_complex_float_acf_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_real_arb_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_complex_acb_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_gr_poly_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_gr_mpoly_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr_series_ctx - :members: - :undoc-members: - -.. autoclass :: flint.types._gr.gr - :members: - :inherited-members: - :undoc-members: diff --git a/doc/source/_static/empty b/doc/source/_static/empty deleted file mode 100644 index e69de29b..00000000 diff --git a/doc/source/acb.rst b/doc/source/acb.rst deleted file mode 100644 index 03c8d203..00000000 --- a/doc/source/acb.rst +++ /dev/null @@ -1,8 +0,0 @@ -**acb** -- complex numbers -=============================================================================== - -.. autoclass :: flint.acb - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/acb_mat.rst b/doc/source/acb_mat.rst deleted file mode 100644 index 2646c2f1..00000000 --- a/doc/source/acb_mat.rst +++ /dev/null @@ -1,8 +0,0 @@ -**acb_mat** -- matrices over complex numbers -=============================================================================== - -.. autoclass :: flint.acb_mat - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/acb_poly.rst b/doc/source/acb_poly.rst deleted file mode 100644 index c58726be..00000000 --- a/doc/source/acb_poly.rst +++ /dev/null @@ -1,8 +0,0 @@ -**acb_poly** -- polynomials over complex numbers -=============================================================================== - -.. autoclass :: flint.acb_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/acb_series.rst b/doc/source/acb_series.rst deleted file mode 100644 index 07691255..00000000 --- a/doc/source/acb_series.rst +++ /dev/null @@ -1,8 +0,0 @@ -**acb_series** -- power series over complex numbers -=============================================================================== - -.. autoclass :: flint.acb_series - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/acb_theta.rst b/doc/source/acb_theta.rst deleted file mode 100644 index f9ccfdd2..00000000 --- a/doc/source/acb_theta.rst +++ /dev/null @@ -1,5 +0,0 @@ -**acb_theta** -- Riemann theta functions -=============================================================================== - -.. autofunction :: flint.types.acb_theta.acb_theta - diff --git a/doc/source/arb.rst b/doc/source/arb.rst deleted file mode 100644 index 4ead6c9a..00000000 --- a/doc/source/arb.rst +++ /dev/null @@ -1,8 +0,0 @@ -**arb** -- real numbers -=============================================================================== - -.. autoclass :: flint.arb - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/arb_mat.rst b/doc/source/arb_mat.rst deleted file mode 100644 index e90c7de7..00000000 --- a/doc/source/arb_mat.rst +++ /dev/null @@ -1,8 +0,0 @@ -**arb_mat** -- matrices over real numbers -=============================================================================== - -.. autoclass :: flint.arb_mat - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/arb_poly.rst b/doc/source/arb_poly.rst deleted file mode 100644 index 80253a29..00000000 --- a/doc/source/arb_poly.rst +++ /dev/null @@ -1,8 +0,0 @@ -**arb_poly** -- polynomials over real numbers -=============================================================================== - -.. autoclass :: flint.arb_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/arb_series.rst b/doc/source/arb_series.rst deleted file mode 100644 index 987e39cb..00000000 --- a/doc/source/arb_series.rst +++ /dev/null @@ -1,8 +0,0 @@ -**arb_series** -- power series over real numbers -=============================================================================== - -.. autoclass :: flint.arb_series - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/build.rst b/doc/source/build.rst deleted file mode 100644 index 9861d50d..00000000 --- a/doc/source/build.rst +++ /dev/null @@ -1,515 +0,0 @@ -Install/Build from source -========================= - -.. note:: - The instructions here are for building ``python-flint`` from source. For - most users it is recommended to install prebuilt binaries from ``PyPI`` or - ``conda-forge`` instead. The instructions here are only needed if a binary - is not available for the platform. See :ref:`install_pip_conda`. - - -.. _simple_build_instructions: - -Simple build instructions -------------------------- - -The simple explanation of how to build ``python-flint`` from source is that -there are two steps: - -- Install ``FLINT >= 3.0`` (see :ref:`installing_the_dependencies` below). -- Run ``pip install --no-binary python-flint python-flint``. - -For example on Ubuntu 24.04 (but not older versions of Ubuntu) and when installing -``python-flint >= 0.7.0`` these two steps are:: - - sudo apt-get install libflint-dev - pip install --no-binary python-flint python-flint - -The first command installs ``FLINT 3.0.1`` system-wide. With the second command -``pip`` will download the source code for the latest release of -``python-flint`` from PyPI, build it and install it into the active Python -environment. When building, ``pip`` will create a temporary isolated build -environment and will install the Python build dependencies (``Cython``, -``meson``, ...) into this environment so it is not necessary to install them -manually before running ``pip install``. - -If you have the source code locally then you can build and install with:: - - pip install path/to/python-flint-directory-or-archive - -After installing from source it is recommended to run the tests to check that -everything is working correctly as described in :ref:`test_installation`. - -The remainder of this page provides more detailed instructions for: - -- :ref:`supported_versions`. -- :ref:`building_from_source`. -- :ref:`building_older_versions`. -- :ref:`installing_the_dependencies`. -- :ref:`building_on_windows`. -- :ref:`non_standard_location`. -- :ref:`editable_install`. - -.. note:: - If you have more than one Python environment in your system then you need to - ensure that you are installing ``python-flint`` into the correct one. This - may require using the full path to ``pip`` or something like ``python3 -m - pip`` or you may need to activate the environment first. - - -.. _supported_versions: - -Compatibility and supported versions ------------------------------------- - -.. note:: - The compatibility information here is mostly only relevant when building - ``python-flint`` from source. For most users it is recommended to install - pre-built binaries from ``PyPI`` or ``conda-forge``. See - :ref:`install_pip_conda`. - -Generally each release of python-flint will be compatible with a range of -Python versions as described in `SPEC 0 -`_. 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 (note that 0.7.0 is not yet released): - -.. list-table:: python-flint compatibility - :header-rows: 1 - - * - python-flint - - Release date - - CPython - - FLINT - - Cython - * - 0.7.0 - - Not yet - - 3.10-3.13 - - 3.0-3.2? - - 3.0-3.1? - * - 0.6.0 - - 1st Feb 2024 - - 3.9-3.12 - - 3.0 - - 3.0 - * - 0.5.0 - - 22nd Oct 2023 - - 3.9-3.12 - - 3.0 - - 3.0 - * - 0.4.0 - - 8th Aug 2023 - - 3.9-3.11 - - ``2.9.0`` (``Arb 2.23.0``) - - 3.0 - * - 0.3.0 - - 7th Dec 2018 - - older Python versions - - ``< 3.0`` - - ``< 3.0`` - -The minimum and maximum versions of Python represent the versions that are -tested in CI and for which binaries are provided on PyPI. It is likely that -``python-flint`` will work with other versions of Python (particularly older -Python versions) but this is not tested. It is possible that ``conda-forge`` -may provide binaries for other versions of Python. - -The minimum versions of Cython and FLINT are needed because it is known that -python-flint will not even build with older versions of these libraries. The -maximum versions of all dependencies are speculative and are based on the -versions that are known to work at the time of release. It is possible that -newer versions of Cython and FLINT will work but unlikely. During the year -following the release of ``python-flint 0.4.0`` every non-patch release of -Cython, FLINT, or CPython has required changes to the ``python-flint`` source -code to be able to build at all. In particular the following releases of -Cython, FLINT and CPython had changes that would prevent building all versions -of ``python-flint`` existing at the time: - -- Flint 3.0 (Arb and Flint merged, lots of changes) -- Flint 3.1 (Function signature for ``fmpz_mod_mat`` changed) -- Flint 3.2 (``flint_randinit`` function name changed) -- Cython 3.0 (Handling of dunders changed) -- Cython 3.1 (Removal of ``PyInt_*`` functions) -- CPython 3.12 (Removal of distutils) - -It is expected then that any future untested ``3.x`` version of Cython, FLINT, -or CPython will not be compatible with past versions of ``python-flint`` which -is why the table above lists the versions that were known to work at the time -of release. - -As of python-flint 0.7.0, CPython ``3.13t`` free-threaded builds are tested in -CI but wheels are not provided on PyPI. There are no known issues related to -using python-flint in a `PEP 703 `_ -free-threaded build but it is likely that mutating objects shared by multiple -threads is not safe. - -It is also possible to build and use python-flint for PyPy. Other Python -implementations may work but are not tested. - - -.. _building_from_source: - -Installing python-flint from source ------------------------------------ - -.. note:: - The instructions here are for building ``python-flint`` from source. For - most users it is recommended to install prebuilt binaries from ``PyPI`` or - ``conda-forge`` instead. The instructions here are only needed if a binary - is not available for the platform. See :ref:`install_pip_conda`. - - Also if you are working on ``python-flint`` itself then it is not - recommended to install the package as described here. Instead see the - :ref:`development_workflow` page for how to work on ``python-flint``. - -The source code for ``python-flint`` is available on `GitHub -`_ and source distributions can -be downloaded from PyPI. - -To build from source you must first install the dependencies (see -:ref:`installing_the_dependencies` below for instructions). Once the -dependencies are installed the following command will download the -``python-flint`` source code from PyPI, then build and install it into the -active Python environment:: - - pip install python-flint - -This will try to install a binary first but will otherwise download, build and -install the latest release of ``python-flint`` from PyPI. If you definitely -want to build from source then you can use the ``--no-binary`` option:: - - pip install --no-binary python-flint python-flint - -To install a specific version of ``python-flint`` from PyPI use e.g.:: - - pip install python-flint==0.7.0a4 - -To build and install the latest ``python-flint`` from git master you can -use:: - - pip install git+https://github.com/flintlib/python-flint.git@master - -If you already have the source code downloaded or checked out from git, you can -``cd`` in and build and install with:: - - pip install . - -Alternatively if you would like to build a wheel you can use -``pypa/build`` (first ``pip install build``):: - - python -m build - -Note that wheels built in this way will not include the dependencies (unlike -those distributed on PyPI) and cannot generally be installed on other systems. - -Since ``python-flint 0.7.0`` the build system is ``meson`` and the build -requirements and version constraints are listed in ``pyproject.toml``. When -using build isolation the build requirements are installed in a temporary -virtual environment and so it should not be necessary to install them in the -active Python environment before running ``pip install``. - -To build without build isolation with ``python-flint >= 0.7.0`` the -dependencies should first be installed in the active Python environment:: - - pip install Cython==3.0 meson meson-python ninja - pip install --no-build-isolation . - -The ``meson`` build system will detect the versions of ``FLINT`` and Cython -installed in the system and will fail if they are not versions that were known -to be compatible at the time of the release of ``python-flint``. To build -against new, untested versions of ``FLINT`` or Cython you can pass the -``-Dflint_version_check=false`` option to the ``meson`` build system:: - - pip install --config-settings=setup-args="-Dflint_version_check=false" . - -This is useful for testing new versions of ``FLINT`` with ``python-flint`` for -example if you want to build ``python-flint`` against the latest git version of -``FLINT``. See :ref:`supported_versions` above for the versions of ``FLINT`` -and Cython that are supported by each version of ``python-flint``. - - -.. _building_older_versions: - -Installing older versions from source -------------------------------------- - -For ``python-flint < 0.6.0`` the source distribution did not include -``pyproject.toml`` and did not list the build requirements. Also for -``python-flint < 0.7.0`` the build requirements were different and there were -no version constraints listed on the dependencies. An list of the build -requirements for older versions of ``python-flint`` is given above in -:ref:`supported_versions`. - -For ``python-flint < 0.7.0`` you will need to install the build requirements -manually, pin the version of Cython, and disable build isolation:: - - pip install Cython==3.0 setuptools numpy - pip install --no-build-isolation . - -For ``python-flint < 0.4.0`` older versions of Cython are needed (``<= 0.29``). -If the build fails during the Cython step then it is likely that a different -version of Cython is needed. - - -.. _installing_the_dependencies: - -Installing the dependencies ---------------------------- - -.. note:: - It is not necessary to install the dependencies manually if you install - from PyPI or conda-forge as is recommended. When installing with ``conda`` - the packages for the dependencies will also be installed from conda-forge - automatically. The binaries on PyPI are built with the dependencies bundled - in the wheel so that they do not need to be installed separately. - - The following instructions are only for when building ``python-flint`` from - source if needed because a binary is not available for your platform. See - :ref:`install_pip_conda`. - -The dependencies for building ``python-flint`` have changed over time. See -:ref:`supported_versions` above for the versions of the dependencies that are -supported by each version of ``python-flint``. - -As of ``python-flint 0.7.0`` the runtime dependencies are Python and FLINT (at -least version 3.0) and the build-time dependencies are a C compiler, -``Cython``, ``meson``, ``meson-python`` and ``ninja``. Commands shown above -such as ``pip install .`` will install dependencies like ``Cython``, ``meson`` -etc automatically. If you already have Python and a C compiler then what needs -to be installed before building ``python-flint`` is ``FLINT``. - -At the time of writing, few Linux distributions provide ``FLINT >= 3.0`` in -their package repositories but for example on ``Ubuntu 24.04`` (but not any -earlier Ubuntu versions) you can install ``FLINT 3.0.1`` with:: - - sudo apt-get install libflint-dev - -On MacOS you can install FLINT from homebrew with:: - - brew install flint - -Other package managers may also provide ``FLINT`` but make sure that it is at -least version ``3.0``. - -Once ``FLINT`` is installed it should be possible to build ``python-flint`` -with any of the commands shown above e.g.:: - - pip install . - -If it is not possible to install FLINT from a package manager then you need to -install GMP and MPFR and then build FLINT. You may still be able to install GMP -and MPFR from a package manager for example on Ubuntu:: - - sudo apt-get install libgmp-dev libmpfr-dev - -The python-flint git repo has a script `bin/install_flint_ubuntu.sh -`_ -that uses ``apt-get`` to install all dependencies needed to build ``FLINT``, -then builds ``FLINT`` from git using a specified git ref, and then installs -``FLINT`` system-wide:: - - bin/install_flint_ubuntu.sh v3.0.1 # version 3.0.1 - bin/install_flint_ubuntu.sh main # latest git - -The script can be adapted for other Linux distributions or MacOS to use -something other than ``apt-get`` to install dependencies. - -If the whole stack needs to be built from source then download the source for -all three (`GMP `_, `MPFR -`_, `FLINT -`_) and build each with the standard:: - - ./configure - make - make install - -Adapt the ``configure`` commands as needed. Once these are installed you should -again be able to install ``python-flint`` with:: - - pip install . - - -.. _building_on_windows: - -Installing from source on Windows ---------------------------------- - -.. note:: - Building from source is not the recommended way for most users to install - ``python-flint``, especially on Windows. For most users it is recommended to - use the binaries from ``PyPI`` or ``conda-forge`` except in cases where a - binary is not available for the platform. See :ref:`install_pip_conda`. - -The instructions in :ref:`installing_the_dependencies` above are for Unix-like systems -(e.g. Linux or MacOS). On Windows the dependencies can be built in a similar -way using MSYS2 or under WSL. It is also possible to build ``python-flint`` and -its dependencies using MSVC but we do not currently provide instructions for -this. The `conda-forge recipe -`_ for ``python-flint`` -builds on Windows using MSVC. - -The `MSYS2 `_ project provides a Unix-like environment -for Windows and a package manager that can be used to install the dependencies. -The git repo for ``python-flint`` has a script `bin/cibw_before_all_windows.sh -`_ -that installs the dependencies under MSYS2 and builds ``GMP``, ``MPFR``, -``FLINT``. This script is used for building the Windows binaries for PyPI. We -use the ``MinGW64`` (``mingw-w64-x86_64``) toolchain for building on Windows -rather than MSVC because it makes it possible to have a fat build of ``GMP`` -(``--enable-fat``) which bundles micro-architecture specific optimisations for -``x86_64`` in a redistributable shared library. This is important for -performance on modern ``x86_64`` CPUs and is not possible if building ``GMP`` -with MSVC. Since we need to use ``MinGW64`` for building ``GMP`` it is simplest -to use it for building ``MPFR``, ``FLINT`` and ``python-flint`` as well and -means that the same Unix-style build scripts can be used for all platforms. - -The ``python-flint`` project does not have much experience using MSVC. Possibly -it would be better to build ``GMP`` using ``MinGW64`` and then build ``MPFR``, -``FLINT`` and ``python-flint`` using MSVC. It is also possible that it would be -better to build ``GMP``, ``MPFR``, ``FLINT`` using MinGW64 and then build -``python-flint`` using MSVC. Someone with more experience with MSVC would need -to help with this. We would welcome contributions that explain how to build -``python-flint`` and its dependencies using MSVC and/or that improve the build -process for distributed binaries on Windows. - - -.. _non_standard_location: - -Using ``FLINT`` from a non-standard location --------------------------------------------- - -.. note:: - This section is only relevant when building ``python-flint`` from source. - For most users it is recommended to use the binaries from ``PyPI`` or - ``conda-forge``. See :ref:`install_pip_conda`. The instructions here are - also not needed if you have installed ``FLINT`` and its dependencies - system-wide (e.g. using a package manager like ``apt-get`` or ``brew``). - -If you have installed ``FLINT`` in a non-standard location then you will need -to instruct the ``python-flint`` build system where to find it and ensure that -the ``FLINT`` shared library can be found at runtime. - -Since ``python-flint 0.7.0`` the build system is `meson -`_ and uses `pkg-config -`_ to find the -dependencies ``FLINT``, ``GMP`` and ``MPFR``. If these are installed in a -non-standard location then you can set the ``PKG_CONFIG_PATH`` environment -variable to point to the directory containing the ``.pc`` files for these -libraries. For example if you have installed ``FLINT`` in ``~/.local`` then you -can set the environment variable like this:: - - export PKG_CONFIG_PATH=$(pwd)/.local/lib/pkgconfig - -Note that in some systems the ``lib/pkgconfig`` directory may be in a different -location e.g. ``lib64/pkgconfig``. It is also possible to pass the path to the -``pkg-config`` files to the ``meson-python`` build backend. For example if -building with ``pip``:: - - pip install \ - --config-settings=setup-args="--pkg-config-path=$(pwd)/.local/lib/pkgconfig" \ - python-flint - -Setting the path to the ``pkg-config`` files in this way will allow the -``python-flint`` build system to find the ``FLINT`` library at build time. At -runtime the ``GMP``, ``MPFR`` and ``FLINT`` shared libraries must be in a -location where the dynamic linker can find them. On Linux the environment -variable ``LD_LIBRARY_PATH`` can be used to add the directory containing the -shared libraries to the search path. On MacOS the environment variable is -``DYLD_LIBRARY_PATH`` and on Windows it is ``PATH``. For example on Linux if -``FLINT`` is installed in ``~/.local/lib`` then you can set the environment -variable:: - - export LD_LIBRARY_PATH=$(pwd)/.local/lib - -Using the environment variable like this means that it needs to be set every -time you run Python and use ``python-flint`` (the git repo provides ``source -bin/activate`` for doing this). A better option on Unix-like systems is to -install ``RPATH`` entries into the ``python-flint`` extension modules. On some -platforms this is done automatically by the ``meson`` build system but on -others it needs to be enabled explicitly. This can be done by passing the -``-Dadd_flint_rpath=true`` option to the ``meson`` build system:: - - pip install \ - --config-settings=setup-args="--pkg-config-path=$(pwd)/.local/lib/pkgconfig" \ - --config-settings=setup-args="-Dadd_flint_rpath=true" \ - python-flint - -For versions of ``python-flint`` before ``0.7.0`` the build system is -``setuptools`` (or ``numpy.distutils`` for ``Python < 3.12``). In this case -``pkg-config`` is not used. The following environment variables can be used to -set the location of the ``FLINT`` and other shared libraries at build time or -runtime:: - - C_INCLUDE_PATH=$(pwd)/.local/include # build-time - LIBRARY_PATH=$(pwd)/.local/lib # build-time - LDFLAGS=-Wl,-rpath=$(pwd)/.local/lib # build-time Linux or MacOS - LD_LIBRARY_PATH=$(pwd)/.local/lib # run-time Linux - DYLD_LIBRARY_PATH=$(pwd)/.local/lib # run-time MacOS - PATH=$(pwd)/.local/bin:$PATH # run-time Windows - -A future improvement for ``python-flint`` could be if the meson build system -could build all dependencies (``GMP``, ``MPFR``, ``FLINT``) as shared libraries -and bundle them into ``python-flint`` although `this is not currently possible -with meson-python -`_. Otherwise -perhaps it could be possible to link ``FLINT`` and the other libraries -statically into ``python-flint``. - - -.. _editable_install: - -Installing in editable mode ---------------------------- - -.. note:: - For working on ``python-flint`` itself it is not recommended to install the - package into the active Python environment. Instead the development workflow - uses ``spin`` and ``meson`` to manage a local build of ``python-flint``. See - the :ref:`development_workflow` page for more information on how to develop - ``python-flint``. - -If you are building and testing ``python-flint`` while working on another -project then it may be useful to install ``python-flint`` in editable mode. -This allows making changes to the code of ``python-flint`` and seeing the -changes reflected in the other environment without needing to reinstall -``python-flint`` each time. This might be useful for example if you are using -``git bisect`` to find a change in ``python-flint`` (although it will not work -if you go back to versions before ``0.7.0``). - -Since ``0.7.0`` it is possible to install ``python-flint`` as a -`meson-python editable install -`_. -To install ``python-flint`` in editable mode, first install ``FLINT`` and -then:: - - 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 - -This requires ``--no-build-isolation`` so that the build directory is not -deleted after install. Once installed in editable mode, each time Python is -restarted and ``python-flint`` is imported (``import flint``) an import hook -will check if the source code has changed and if so will rebuild the extension -modules and update the Python files. The rebuild uses ``meson`` for fast, -parallel, incremental rebuilds. Note that for the rebuild to happen and for the -changes to take effect it is necessary to start a new Python process e.g. by -running ``python`` again or by restarting the Jupyter kernel. - -If you have installed ``FLINT`` in a non-standard location then you should set -the ``pkg-config`` path as described in :ref:`non_standard_location` above:: - - pip install - --no-build-isolation \ - --config-settings=setup-args="--pkg-config-path=$(pwd)/.local/lib/pkgconfig" \ - --editable . - -To fully remove the editable install you can run:: - - pip uninstall python-flint - -and then delete the ``build`` directory that was created in the root of the -``python-flint`` git repo. diff --git a/doc/source/conf.py b/doc/source/conf.py deleted file mode 100644 index 6b232bfb..00000000 --- a/doc/source/conf.py +++ /dev/null @@ -1,251 +0,0 @@ -# -*- coding: utf-8 -*- -# -# python-flint documentation build configuration file, created by -# sphinx-quickstart on Wed Jul 18 11:49:46 2012. -# -# This file is execfile()d with the current directory set to its containing dir. -# -# Note that not all possible configuration values are present in this -# autogenerated file. -# -# All configuration values have a default; values that are commented out -# serve to show the default. - -import sys -import os - -# If extensions (or modules to document with autodoc) are in another directory, -# add these directories to sys.path here. If the directory is relative to the -# documentation root, use os.path.abspath to make it absolute, like shown here. -#sys.path.insert(0, os.path.abspath('.')) - -# -- General configuration ----------------------------------------------------- - -# If your documentation needs a minimal Sphinx version, state it here. -#needs_sphinx = '1.0' - -# Add any Sphinx extension module names here, as strings. They can be extensions -# coming with Sphinx (named 'sphinx.ext.*') or your custom ones. -extensions = ['sphinx.ext.autodoc', 'sphinx.ext.doctest', 'sphinx.ext.mathjax', 'sphinx.ext.viewcode'] - -# TODO: get this to work? -autodoc_member_order = 'bysource' - -# Add any paths that contain templates here, relative to this directory. -templates_path = ['_templates'] - -# The suffix of source filenames. -source_suffix = '.rst' - -# The encoding of source files. -#source_encoding = 'utf-8-sig' - -# The master toctree document. -master_doc = 'index' - -# General information about the project. -project = u'python-flint' -copyright = u'2012, Fredrik Johansson' - -# The version info for the project you're documenting, acts as replacement for -# |version| and |release|, also used in various other places throughout the -# built documents. -# -# The short X.Y version. -version = '0.8.0' -# The full version, including alpha/beta/rc tags. -release = '0.8.0' - -# The language for content autogenerated by Sphinx. Refer to documentation -# for a list of supported languages. -#language = None - -# There are two options for replacing |today|: either, you set today to some -# non-false value, then it is used: -#today = '' -# Else, today_fmt is used as the format for a strftime call. -#today_fmt = '%B %d, %Y' - -# List of patterns, relative to source directory, that match files and -# directories to ignore when looking for source files. -exclude_patterns = [] - -# The reST default role (used for this markup: `text`) to use for all documents. -default_role = 'math' - -latex_preamble = r""" -\usepackage{amsmath,amssymb} -\setcounter{tocdepth}{2} -""" - -# If true, '()' will be appended to :func: etc. cross-reference text. -#add_function_parentheses = True - -# If true, the current module name will be prepended to all description -# unit titles (such as .. function::). -#add_module_names = True - -# If true, sectionauthor and moduleauthor directives will be shown in the -# output. They are ignored by default. -#show_authors = False - -# The name of the Pygments (syntax highlighting) style to use. -pygments_style = 'sphinx' - -# A list of ignored prefixes for module index sorting. -#modindex_common_prefix = [] - - -# -- Options for HTML output --------------------------------------------------- - -# The theme to use for HTML and HTML Help pages. See the documentation for -# a list of builtin themes. -html_theme = 'furo' - -# Theme options are theme-specific and customize the look and feel of a theme -# further. For a list of options available for each theme, see the -# documentation. -#html_theme_options = {} - -# Add any paths that contain custom themes here, relative to this directory. -#html_theme_path = [] - -# The name for this set of Sphinx documents. If None, it defaults to -# " v documentation". -#html_title = None - -# A shorter title for the navigation bar. Default is the same as html_title. -#html_short_title = None - -# The name of an image file (relative to this directory) to place at the top -# of the sidebar. -#html_logo = None - -# The name of an image file (within the static path) to use as favicon of the -# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 -# pixels large. -#html_favicon = None - -# Add any paths that contain custom static files (such as style sheets) here, -# relative to this directory. They are copied after the builtin static files, -# so a file named "default.css" will overwrite the builtin "default.css". -html_static_path = ['_static'] - -# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, -# using the given strftime format. -#html_last_updated_fmt = '%b %d, %Y' - -# If true, SmartyPants will be used to convert quotes and dashes to -# typographically correct entities. -#html_use_smartypants = True - -# Custom sidebar templates, maps document names to template names. -#html_sidebars = {} - -# Additional templates that should be rendered to pages, maps page names to -# template names. -#html_additional_pages = {} - -# If false, no module index is generated. -#html_domain_indices = True - -# If false, no index is generated. -#html_use_index = True - -# If true, the index is split into individual pages for each letter. -#html_split_index = False - -# If true, links to the reST sources are added to the pages. -#html_show_sourcelink = True - -# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. -#html_show_sphinx = True - -# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. -#html_show_copyright = True - -# If true, an OpenSearch description file will be output, and all pages will -# contain a tag referring to it. The value of this option must be the -# base URL from which the finished HTML is served. -#html_use_opensearch = '' - -# This is the file name suffix for HTML files (e.g. ".xhtml"). -#html_file_suffix = None - -# Output file base name for HTML help builder. -htmlhelp_basename = 'python-flintdoc' - - -# -- Options for LaTeX output -------------------------------------------------- - -latex_elements = { -# The paper size ('letterpaper' or 'a4paper'). -#'papersize': 'letterpaper', - -# The font size ('10pt', '11pt' or '12pt'). -#'pointsize': '10pt', - -# Additional stuff for the LaTeX preamble. -#'preamble': '', -} - -# Grouping the document tree into LaTeX files. List of tuples -# (source start file, target name, title, author, documentclass [howto/manual]). -latex_documents = [ - ('index', 'python-flint.tex', u'python-flint Documentation', - u'Fredrik Johansson', 'manual'), -] - -# The name of an image file (relative to this directory) to place at the top of -# the title page. -#latex_logo = None - -# For "manual" documents, if this is true, then toplevel headings are parts, -# not chapters. -#latex_use_parts = False - -# If true, show page references after internal links. -#latex_show_pagerefs = False - -# If true, show URL addresses after external links. -#latex_show_urls = False - -# Documents to append as an appendix to all manuals. -#latex_appendices = [] - -# If false, no module index is generated. -#latex_domain_indices = True - - -# -- Options for manual page output -------------------------------------------- - -# One entry per manual page. List of tuples -# (source start file, name, description, authors, manual section). -man_pages = [ - ('index', 'python-flint', u'python-flint Documentation', - [u'Fredrik Johansson'], 1) -] - -# If true, show URL addresses after external links. -#man_show_urls = False - - -# -- Options for Texinfo output ------------------------------------------------ - -# Grouping the document tree into Texinfo files. List of tuples -# (source start file, target name, title, author, -# dir menu entry, description, category) -texinfo_documents = [ - ('index', 'python-flint', u'python-flint Documentation', - u'Fredrik Johansson', 'python-flint', 'One line description of project.', - 'Miscellaneous'), -] - -# Documents to append as an appendix to all manuals. -#texinfo_appendices = [] - -# If false, no module index is generated. -#texinfo_domain_indices = True - -# How to display URL addresses: 'footnote', 'no', or 'inline'. -#texinfo_show_urls = 'footnote' diff --git a/doc/source/dirichlet.rst b/doc/source/dirichlet.rst deleted file mode 100644 index 2f29d865..00000000 --- a/doc/source/dirichlet.rst +++ /dev/null @@ -1,13 +0,0 @@ -**dirichlet_char** -- Dirichlet characters -=============================================================================== - -.. autoclass :: flint.dirichlet_group - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.dirichlet_char - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpq.rst b/doc/source/fmpq.rst deleted file mode 100644 index 7cfb8f6c..00000000 --- a/doc/source/fmpq.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpq** -- rational numbers -=============================================================================== - -.. autoclass :: flint.fmpq - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpq_mat.rst b/doc/source/fmpq_mat.rst deleted file mode 100644 index 69ef358e..00000000 --- a/doc/source/fmpq_mat.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpq_mat** -- matrices over rational numbers -=============================================================================== - -.. autoclass :: flint.fmpq_mat - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpq_mpoly.rst b/doc/source/fmpq_mpoly.rst deleted file mode 100644 index bce01253..00000000 --- a/doc/source/fmpq_mpoly.rst +++ /dev/null @@ -1,18 +0,0 @@ -**fmpq_mpoly** -- multivariate polynomials over the rational numbers -=============================================================================== - -.. autoclass :: flint.fmpq_mpoly_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpq_mpoly - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpq_mpoly_vec - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpq_poly.rst b/doc/source/fmpq_poly.rst deleted file mode 100644 index a38712b3..00000000 --- a/doc/source/fmpq_poly.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpq_poly** -- polynomials over rational numbers -=============================================================================== - -.. autoclass :: flint.fmpq_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpq_series.rst b/doc/source/fmpq_series.rst deleted file mode 100644 index 16be89cd..00000000 --- a/doc/source/fmpq_series.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpq_series** -- power series over rational numbers -=============================================================================== - -.. autoclass :: flint.fmpq_series - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz.rst b/doc/source/fmpz.rst deleted file mode 100644 index 8a9e2fe1..00000000 --- a/doc/source/fmpz.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpz** -- integers -=============================================================================== - -.. autoclass :: flint.fmpz - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_mat.rst b/doc/source/fmpz_mat.rst deleted file mode 100644 index 3617eb16..00000000 --- a/doc/source/fmpz_mat.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpz_mat** -- matrices over integers -=============================================================================== - -.. autoclass :: flint.fmpz_mat - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_mod.rst b/doc/source/fmpz_mod.rst deleted file mode 100644 index 67e3206d..00000000 --- a/doc/source/fmpz_mod.rst +++ /dev/null @@ -1,13 +0,0 @@ -**fmpz_mod** -- integers mod n -=============================================================================== - -.. autoclass :: flint.fmpz_mod_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpz_mod - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_mod_mat.rst b/doc/source/fmpz_mod_mat.rst deleted file mode 100644 index 73e9f012..00000000 --- a/doc/source/fmpz_mod_mat.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpz_mod_mat** -- matrices over integers mod n for arbitrary n -=============================================================================== - -.. autoclass :: flint.fmpz_mod_mat - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_mod_mpoly.rst b/doc/source/fmpz_mod_mpoly.rst deleted file mode 100644 index d28c0faa..00000000 --- a/doc/source/fmpz_mod_mpoly.rst +++ /dev/null @@ -1,18 +0,0 @@ -**fmpz_mod_mpoly** -- multivariate polynomials over the integers mod n -=============================================================================== - -.. autoclass :: flint.fmpz_mod_mpoly_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpz_mod_mpoly - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpz_mod_mpoly_vec - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_mod_poly.rst b/doc/source/fmpz_mod_poly.rst deleted file mode 100644 index 1af54bb6..00000000 --- a/doc/source/fmpz_mod_poly.rst +++ /dev/null @@ -1,13 +0,0 @@ -**fmpz_mod_poly** -- polynomials over integers mod n -=============================================================================== - -.. autoclass :: flint.fmpz_mod_poly_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpz_mod_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_mpoly.rst b/doc/source/fmpz_mpoly.rst deleted file mode 100644 index cbdb776e..00000000 --- a/doc/source/fmpz_mpoly.rst +++ /dev/null @@ -1,18 +0,0 @@ -**fmpz_mpoly** -- multivariate polynomials over the integers -=============================================================================== - -.. autoclass :: flint.fmpz_mpoly_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpz_mpoly - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fmpz_mpoly_vec - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_poly.rst b/doc/source/fmpz_poly.rst deleted file mode 100644 index 54c913c6..00000000 --- a/doc/source/fmpz_poly.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpz_poly** -- polynomials over integers -=============================================================================== - -.. autoclass :: flint.fmpz_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fmpz_series.rst b/doc/source/fmpz_series.rst deleted file mode 100644 index 28b60e64..00000000 --- a/doc/source/fmpz_series.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fmpz_series** -- power series over integers -=============================================================================== - -.. autoclass :: flint.fmpz_series - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fq_default.rst b/doc/source/fq_default.rst deleted file mode 100644 index bea090f9..00000000 --- a/doc/source/fq_default.rst +++ /dev/null @@ -1,8 +0,0 @@ -**fq_default** -- finite fields -=============================================================================== - -.. autoclass :: flint.fq_default - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/fq_default_poly.rst b/doc/source/fq_default_poly.rst deleted file mode 100644 index 13da4d3b..00000000 --- a/doc/source/fq_default_poly.rst +++ /dev/null @@ -1,13 +0,0 @@ -**fq_default_poly** -- polynomials over finite fields -=============================================================================== - -.. autoclass :: flint.fq_default_poly_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.fq_default_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/general.rst b/doc/source/general.rst deleted file mode 100644 index 797bb67d..00000000 --- a/doc/source/general.rst +++ /dev/null @@ -1,209 +0,0 @@ -General concepts -=============================================================================== - -Importing ------------------ - -The ``flint`` module exposes a set of distinctly-named types together -with a small number of top-level functions and objects. -Most functionality is provided as methods on the types. This means -that there should be no namespace conflicts with most user code, -with Python's builtin ``math`` and ``cmath`` modules, or with -packages such as ``gmpy``, ``numpy``, ``sympy`` and ``mpmath``. -For typical interactive use, it should therefore -generally be safe to ``import *``: - - >>> from flint import * - >>> fmpq(3) / 2 - 3/2 - -For non-interactive use, it is still good manners to use explicit -imports or preserve the ``flint`` namespace prefix:: - - >>> import flint - >>> flint.fmpq(3) / 2 - 3/2 - -Global context ------------------ - -Various settings are controlled by a global context object, -``flint.ctx``. Printing this object in the REPL shows the current -settings, with a brief explanation of each parameter:: - - >>> 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 - -The user can mutate the properties directly, for example:: - - >>> ctx.pretty = False - >>> fmpq(3,2) - fmpq(3,2) - >>> ctx.pretty = True - >>> fmpq(3,2) - 3/2 - -Calling ``ctx.default()`` restores the default settings. - -The special method ``ctx.cleanup()`` frees up internal caches -used by MPFR, FLINT and Arb. The user does normally not have to -worry about this. - -The context object ``flint.ctx`` can be controlled locally to increase the -working precision using python context managers:: - - >>> arb(2).sqrt() - [1.41421356237309 +/- 5.15e-15] - >>> with ctx.extraprec(15): - ... arb(2).sqrt() - ... - [1.414213562373095049 +/- 2.10e-19] - -In the same manner, it is possible to exactly set the working precision, -or to update it in terms of digits:: - - >>> with ctx.extradps(15): - ... arb(2).sqrt() - ... - [1.41421356237309504880168872421 +/- 6.27e-31] - >>> with ctx.workprec(15): - ... arb(2).sqrt() - ... - [1.414 +/- 2.46e-4] - -Types and methods ------------------ - -As a general rule, C functions associated with a type in FLINT or Arb -are exposed as methods of the corresponding Python type. - -For example, there is both an :meth:`.fmpq.bernoulli` (which computes -a Bernoulli number as an exact fraction) and :meth:`.arb.bernoulli` -(which computes a Bernoulli number as an approximate real number). - -A function that transforms a single value to the same type -is usually an ordinary method of that type, for instance :meth:`.arb.exp`. -A function with a different signature can either provided as a -static method that takes all inputs as function arguments, or as a -method of the "primary" input, taking the other inputs -as arguments to the method (for example :meth:`.arb.bessel_j`). - -When a method involves different types for inputs and outputs (or -just among the inputs), it will -typically be a method of the more "complex" type. For example, a matrix -type is more "complex" than the underlying scalar type, so -:meth:`.fmpz_mat.det` is a method of the matrix type, returning a scalar, -and not vice versa. - -The method-based interface is intended to keep the code simple, -not to be aesthetically pleasing to mathematicians. A functional -top-level interface might be added in the future, allowing more idiomatic -mathematical notation (for example, :func:`exp` and -:func:`det` as regular functions). - -Mutability ----------- - -Objects have immutable semantics. For example, the second line in:: - - b = a - a += c - -leaves *b* unchanged. - -However, mutation via direct element access is supported for matrices -and polynomials. Some methods also allow explicitly performing the -operation in-place. Civilized users will restrict their use of such -methods to the point in the code where the object is first constructed:: - - def create_thing(): # ok - a = thing() - a.mutate() - return a - -Crashing and burning ---------------------------------------- - -Very little overflow checking is done ahead-of-time. Trying to compute an -object far too large to hold in memory (for example, the exact factorial -of `2^{64}-1`) will likely abort the process, -instead of raising an :exc:`OverflowError` or :exc:`MemoryError` that -can be caught at the Python level. - -Input that is obviously *invalid* (for example a negative number passed -as a length) can also cause crashes or worse things to happen. -Ideally, bad input should be caught at the Python level and result in -appropriate exceptions being raised, but this is not yet done -systematically. At this time, users should assume that invalid -input leads to undefined behavior! - -Inexact numbers and numerical evaluation ------------------------------------------------------------------------ - -Real and complex numbers are represented by midpoint-radius intervals -(balls). All operations on real and complex numbers output intervals -representing rigorous error bounds. This also extends to polynomials -and matrices of real and complex numbers. - -The working precision for real and complex arithmetic is controlled by the -global context object attributes :func:`ctx.prec` (in bits) -:func:`ctx.dps` (in decimal digits). Changing either attribute changes -the other to match. - -Be careful about using Python float and complex literals as input. -Doing ``arb(0.1)`` actually gives an interval containing -the rational number - -.. math :: - - 3602879701896397 \times 2^{-55} = 0.1000000000000000055511151231257827021181583404541015625 - -which might not be what you want. Do ``arb("0.1")``, ``arb("1/10")`` -or ``arb(fmpq(1,10))`` if -you want the correct decimal fraction. Small integers and -power-of-two denominators are still safe, for example ``arb(100.25)``. - -Pointwise boolean predicates (such as the usual comparison operators) -involving inexact numbers return -*True* only if the predicate certainly is true (i.e. it holds for all -combinations of points that can be chosen from the set-valued inputs), -and return *False* if the -predicate either definitely is false or the truth cannot be determined. -To determine that a predicate is definitely false, -test both the predicate and the inverse predicate, -e.g. if either ``x < y`` or ``y <= x`` returns *True*, then the other -is definitely false; if both return *False*, then neither can be -determined from the available data. - -The following convenience functions are provided for numerical evaluation -with adaptive working precision. - -.. autofunction :: flint.showgood - -Power series ------------------------------------------------------------------------ - -Power series objects track the precision (the number of known terms) -automatically. The upper precision for power series is controlled by -``flint.ctx.cap``, with the default value 10. - - >>> fmpq_series([0,1]).exp() - 1 + x + 1/2*x^2 + 1/6*x^3 + 1/24*x^4 + 1/120*x^5 + 1/720*x^6 + 1/5040*x^7 + 1/40320*x^8 + 1/362880*x^9 + O(x^10) - >>> ctx.cap = 4 - >>> fmpq_series([0,1]).exp() - 1 + x + 1/2*x^2 + 1/6*x^3 + O(x^4) - >>> ctx.cap = 10 - >>> fmpq_series([0,1], prec=5).exp() - 1 + x + 1/2*x^2 + 1/6*x^3 + 1/24*x^4 + O(x^5) - - >>> ctx.cap = 3 - >>> ctx.dps = 10 - >>> arb_series([1,3,4]).exp() - ([2.718281828 +/- 4.79e-10]) + ([8.154845485 +/- 4.36e-10])*x + ([23.10539554 +/- 2.25e-9])*x^2 + O(x^3) - >>> ctx.default() diff --git a/doc/source/index.rst b/doc/source/index.rst deleted file mode 100644 index d8bb93e8..00000000 --- a/doc/source/index.rst +++ /dev/null @@ -1,105 +0,0 @@ -.. python-flint documentation master file, created by - sphinx-quickstart on Wed Jul 18 11:49:46 2012. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. - -Python-FLINT -========================================================== - -Python extension module wrapping FLINT_ (Fast Library for Number Theory) -and Arb_ (arbitrary-precision ball arithmetic). Features: - -.. _FLINT: http://flintlib.org/ -.. _Arb: http://arblib.org/ - - -* Integers, rationals, integers mod n -* Real and complex numbers with rigorous error tracking -* Polynomials and matrices over all the above types -* Lots of mathematical functions - -Author: `Fredrik Johansson `_ - -Repository: https://github.com/flintlib/python-flint/ - -Introduction ------------- - -.. toctree:: - :maxdepth: 2 - - install.rst - general.rst - build.rst - workflow.rst - - -Reference ---------- - -Scalar types -............ - -.. toctree:: - :maxdepth: 1 - - fmpz.rst - fmpq.rst - fmpz_mod.rst - nmod.rst - fq_default.rst - arb.rst - acb.rst - dirichlet.rst - -Matrix types -............ - -.. toctree:: - :maxdepth: 1 - - fmpz_mat.rst - fmpq_mat.rst - nmod_mat.rst - fmpz_mod_mat.rst - arb_mat.rst - acb_mat.rst - acb_theta.rst - -Polynomial types -................ - -.. toctree:: - :maxdepth: 1 - - fmpz_poly.rst - fmpz_mpoly.rst - fmpq_poly.rst - fmpq_mpoly.rst - nmod_poly.rst - nmod_mpoly.rst - fmpz_mod_poly.rst - fmpz_mod_mpoly.rst - fq_default_poly.rst - arb_poly.rst - acb_poly.rst - -Power series types -.................. - -.. toctree:: - :maxdepth: 1 - - fmpz_series.rst - fmpq_series.rst - nmod_series.rst - arb_series.rst - acb_series.rst - -Experimental generic rings interface -.................................... - -.. toctree:: - :maxdepth: 2 - - _gr.rst diff --git a/doc/source/install.rst b/doc/source/install.rst deleted file mode 100644 index 6e4ccef8..00000000 --- a/doc/source/install.rst +++ /dev/null @@ -1,137 +0,0 @@ -Install -======= - -.. _install_pip_conda: - -Install with pip or conda -------------------------- - -The recommended way to install ``python-flint`` for general use is to install a -prebuilt binary package. Python-FLINT is available on PyPI, the `Python Package -Index `_. The latest release can be -installed using:: - - pip install python-flint - -.. note:: - If you have more than one Python environment on your system then you should - ensure that you are installing ``python-flint`` into the correct Python - environment. This may require using the full path to ``pip`` or using - something like ``python3 -m pip`` to ensure that ``pip`` is run from the - correct Python environment. - -Python-FLINT is also available from `conda-forge -`_ and can be installed with -``conda``:: - - conda install -c conda-forge python-flint - -Both PyPI and conda-forge provide prebuilt binary packages for ``python-flint`` -for common platforms such as Windows, MacOS and Linux for a range of different -architectures and Python versions. If binaries are available for your platform -then installing from PyPI or conda-forge is simplest and does not require any -other dependencies or configuration. It is also possible that other software -distribution channels may provide binaries for ``python-flint``. - -A specific version of ``python-flint`` can be installed with ``pip`` by -specifying the version number, for example:: - - pip install python-flint==0.6.0 - -After installing ``python-flint`` you can test your installation as described -in :ref:`test_installation` below. - - -Fully supported platforms -------------------------- - -Generally each release of python-flint will be compatible with a range of -Python versions as described in `SPEC 0 -`_. At the time of writing, the -current release of ``python-flint`` is ``0.6.0`` and binaries are provided for -Python 3.9, 3.10 3.11 and 3.12 for the following platforms: - -- Windows 64-bit (``x86_64``) -- MacOS 64-bit Intel and 64-bit ARM (i.e. Apple Silicon) -- Linux 64-bit (``x86_64``, ``manylinux``) - -A WASM build of ``python-flint`` is also available for use in the browser -via `Pyodide `_. - -You can see which binaries are provided for the latest release of -``python-flint`` `from PyPI `_ -and which are provided `from conda-forge -`_. A list of supported versions -of Python and other ``python-flint`` dependencies can be found at -:ref:`supported_versions`. - - -Platforms without binaries --------------------------- - -There are many other platforms on which ``python-flint`` works fine but for -which binaries are not provided. If a binary is not available for your platform -then you may be able to build from source as described in -:ref:`simple_build_instructions`. - -Notably, at the time of writing the following platforms do *not* have binaries -available but ``python-flint`` should work if built from source: - -- Linux aarch64 (``conda-forge`` has binaries but ``PyPI`` does not, see - `gh-105 `_). -- non-glibc Linux distros (e.g. ``musllinux`` rather than ``manylinux``) -- PyPy - -Binaries for Linux aarch64 will likely be added in future when the platform is -available for testing in CI. - - -Unsupported platforms ---------------------- - -It is *not* known or expected that ``python-flint`` will currently work on: - -- Windows on ARM (has never been tested) -- Any 32-bit platform (previously worked but has not been tested for some - time) -- Other Python implementations besides CPython and PyPy (e.g. GraalPython, - Jython, IronPython) - -Support for Windows on ARM will likely be added in future when the platform is -available for testing in CI. - - -.. _test_installation: - -Testing your installation -------------------------- - -However you install ``python-flint``, you can test the installation by running -the test suite (for ``python-flint >= 0.5.0``):: - - python -m flint.test - -This does not take long and will run all the tests and doctests and should -hopefully show something like this:: - - $ 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! - -From Python you can instead run the same tests with:: - - from flint.test.__main__ import main - main() - -If you have installed ``python-flint`` from PyPI or conda-forge as described -above and your installation passes the tests then you are ready to use -``python-flint``. If the tests fail (or do not complete) then please report the -problem on the `python-flint issue tracker -`_. - -If the tests have all passed then ``python-flint`` is installed and ready to -use! diff --git a/doc/source/nmod.rst b/doc/source/nmod.rst deleted file mode 100644 index febc625a..00000000 --- a/doc/source/nmod.rst +++ /dev/null @@ -1,8 +0,0 @@ -**nmod** -- integers mod wordsize n -=============================================================================== - -.. autoclass :: flint.nmod - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/nmod_mat.rst b/doc/source/nmod_mat.rst deleted file mode 100644 index 51e1693f..00000000 --- a/doc/source/nmod_mat.rst +++ /dev/null @@ -1,8 +0,0 @@ -**nmod_mat** -- matrices over integers mod n -=============================================================================== - -.. autoclass :: flint.nmod_mat - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/nmod_mpoly.rst b/doc/source/nmod_mpoly.rst deleted file mode 100644 index cdfb944e..00000000 --- a/doc/source/nmod_mpoly.rst +++ /dev/null @@ -1,18 +0,0 @@ -**nmod_mpoly** -- multivariate polynomials over the integers mod n (word-size n) -================================================================================ - -.. autoclass :: flint.nmod_mpoly_ctx - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.nmod_mpoly - :members: - :inherited-members: - :undoc-members: - -.. autoclass :: flint.nmod_mpoly_vec - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/nmod_poly.rst b/doc/source/nmod_poly.rst deleted file mode 100644 index e84c4bef..00000000 --- a/doc/source/nmod_poly.rst +++ /dev/null @@ -1,8 +0,0 @@ -**nmod_poly** -- polynomials over integers mod n -=============================================================================== - -.. autoclass :: flint.nmod_poly - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/nmod_series.rst b/doc/source/nmod_series.rst deleted file mode 100644 index b91feb42..00000000 --- a/doc/source/nmod_series.rst +++ /dev/null @@ -1,8 +0,0 @@ -**nmod_series** -- power series over integers mod n -=============================================================================== - -.. autoclass :: flint.nmod_series - :members: - :inherited-members: - :undoc-members: - diff --git a/doc/source/workflow.rst b/doc/source/workflow.rst deleted file mode 100644 index b9fa2780..00000000 --- a/doc/source/workflow.rst +++ /dev/null @@ -1,522 +0,0 @@ -.. _development_workflow: - -Development workflow -==================== - -.. note:: - The instructions here are for developing ``python-flint`` e.g. if you want - to contribute to ``python-flint`` such as by making changes to its code. - - For most users it is recommended to install prebuilt binaries from ``PyPI`` - or ``conda-forge`` as explained in :ref:`install_pip_conda`. If you are just - trying to build and install ``python-flint`` from source, see - :ref:`simple_build_instructions`. - - -Outline of building ``python-flint`` for development ----------------------------------------------------- - -The ``python-flint`` project is a Python wrapper around the `FLINT -`_ library. The FLINT library is a C library that -depends on `GMP `_ and `MPFR `_. -The ``python-flint`` codebase is almost entirely written in `Cython -`_ which is a superset of Python that allows writing C -extensions for Python. The Cython code in ``python-flint`` is used to be able -to call the C functions in the FLINT library from Python. - -To develop ``python-flint`` we need to be able to build it which means that we -need to have the FLINT library installed, and to have a C compiler and also the -Python build dependencies such as Cython installed. Installing the FLINT -library is covered in :ref:`installing_the_dependencies` although you may want -to use a local build of FLINT for development as is explained in -:ref:`local_dependency_install` below. - -Once the dependencies are installed, ``python-flint`` itself needs to be built -which happens in four steps: - -1. The Cython code in ``python-flint`` is compiled to C code using ``cython``. -2. The C code generated by ``cython`` is compiled to Python extension modules - (shared libraries) using a C compiler and these are linked against the FLINT - library and other dependencies. -3. The extension modules and Python files are all assembled into a Python - package directory. -4. The Python package directory is bundled into a wheel (a zip file). - -When building to install the next step would be: - -5. The wheel is installed using a Python package installer such as ``pip``. - -When building for distribution on PyPI the next steps would instead be: - -5. All of the dependencies such as the FLINT library are bundled into the - wheel. -6. The wheel is uploaded to ``PyPI``. -7. Users install the wheel from PyPI (``pip install python-flint``). - -The ``python-flint`` project uses ``meson``, ``meson-python`` and ``spin`` to -manage steps 1-4 and other development tasks like running tests. For local -development, only steps 1-3 are needed and then the package directory is used -directly to run tests or other commands. Using ``meson`` and ``spin`` for -developing ``python-flint`` is explained below. - - -.. _local_dependency_install: - -Building and installing dependencies locally --------------------------------------------- - -It can be useful to build and install the dependencies of ``python-flint`` -locally rather than system-wide. This is useful for development because it -allows you to have precise control over the versions of the dependencies used -for development without conflicting with system-wide installations. - -In the ``python-flint`` git repo there is a script -`bin/build_dependencies_unix.sh -`_ -which will download and build GMP, MPFR and FLINT and install them under the -current directory in a subdirectory called ``.local``. The versions used and -the installation directory can be changed by editing the -`bin/build_variables.sh -`_ -script. This script is useful for building ``python-flint`` on systems where -the system-wide ``FLINT`` is too old or if precise control over the versions of -GMP, MPFR and FLINT is needed (e.g. when developing ``python-flint`` and -testing different versions). This script is used for building the binaries for -PyPI and also takes care of ensuring that ``GMP`` and ``FLINT`` are built as -redistributable shared libraries (this is not the default behaviour of the -``configure`` scripts for these libraries and disables some optimisation -features of ``FLINT`` on some ``x86_64`` micro-architectures). - -Since this local installation is not system-wide, see -:ref:`non_standard_location` and the instructions below for how to configure -``meson`` to use the locally installed dependencies. - - -Meson and spin --------------- - -The build system for ``python-flint`` uses `meson `_ -and is configured using ``meson.build`` and ``meson.options`` files. When -installing ``python-flint`` with e.g. ``pip install .`` the `meson-python -`_ PEP 517 `build backend -`_ will instruct ``meson`` to build a -``python-flint`` wheel that ``pip`` will then install. - -For development it is preferred not to install ``python-flint`` into the -active environment but to use ``meson`` commands directly to create a local -build and then run tests or other commands using the local build. The `spin -`_ tool is then used as a frontend -to ``meson`` to simplify common development tasks. We will first explain how to -use ``meson`` directly and then show how to use ``spin`` to simplify the -process. This section gives an overview of how ``meson`` and ``spin`` are used -and in the next section we will see how to get started with using these for -``python-flint`` development. - -To build and install a typical (non-Python) project that uses ``meson`` you -would run:: - - meson setup build - meson compile -C build - meson install -C build - -These three commands create a build directory, compile the project, and install -it and are analogous to the autotools commands:: - - ./configure - make - make install - -What each of these commands does is: - -- ``meson setup build``: Create a build directory called ``build``. Options can - be passed to the ``meson setup`` command to configure how the project will be - built. -- ``meson compile -C build``: Build the project and place the built files in - the ``build`` directory. After the initial build, if some code is changed - then ``meson compile`` performs an incremental build which is faster then - rebuilding from scratch. -- ``meson install -C build``: Transfer the built files to the install directory - (e.g. ``/usr/local`` or somewhere). - -In a Python project that uses ``meson``, the ``meson install`` command is not -usually used like this because the ``meson`` build system is typically used to -build e.g. a wheel that is then installed using a Python package installer such -as ``pip``. - -In the ``spin/meson`` workflow for Python projects, we would instead "install" -the project into a local directory with a command like:: - - meson install --only-changed -C build --destdir ../build-install - -This command installs the project into the local ``build-install`` directory -which is a subdirectory of the project root directory. For common development -tasks like running the tests we need to make it so that Python can import this -local build of ``python-flint`` which can be done by either setting -``PYTHONPATH`` or by changing directory to where the local build is installed:: - - cd build-install/usr/lib/python3.12/site-packages - python -m flint.test - -This will run the tests for ``python-flint`` using the local build of -``python-flint``. The ``spin`` tool simplifies this process by providing a -frontend to ``meson`` that can be used to run common development tasks like -running the tests. To run the tests using ``spin`` you can run:: - - spin test - -This will rebuild the project if necessary and then run the tests using the -local build of ``python-flint``. The ``spin`` tool will show what commands it -is effectively running so you can see what is happening if you want to run the -commands directly. In this case ``spin test`` is roughly equivalent to:: - - meson compile -C build # rebuild - meson install --only-changed -C build --destdir ../build-install - export PYTHONPATH="/path/to/python-flint/build-install/usr/lib/python3.12/site-packages" - python -m pytest --pyargs flint - -After any change to the code, common development tasks such as running the -tests require the project to be built and installed first. With ``spin`` and -``meson`` we emulate this without needing to perform a full rebuild and without -actually installing the project into any Python environment or system-wide -location. - - -Setting up the development environment --------------------------------------- - -First create a fork of the `python-flint repository on GitHub -`_. Clone your fork to your local -machine using ``git`` and then change directory into the cloned repository: - -.. code-block:: bash - - git clone git@github.com:your-username/python-flint.git - cd python-flint - -Now add the upstream repository as a remote so that you can pull in changes in -future: - -.. code-block:: bash - - git remote add upstream git@github.com:flintlib/python-flint.git - -.. note:: - The git URLs with ``git@`` are for SSH access to the repository. If you do - not use SSH keys with GitHub then use the HTTPS URLs instead. - -It is worth reading the :ref:`simple_build_instructions` instructions first -because they cover the basic dependencies needed to build ``python-flint`` from -source and :ref:`installing_the_dependencies`. For local development, you may -want to install non-Python dependencies such as ``FLINT`` locally rather than -system-wide in which case the instructions in :ref:`local_dependency_install` -and :ref:`non_standard_location` are also useful. - -It is also useful to use a `virtual environment -`_ to manage the Python-level -dependencies for ``python-flint`` so that it is kept separate from other Python -environments on your system. You can create and activate a virtual environment -using e.g.: - -.. code-block:: bash - - python3 -m venv venv - source venv/bin/activate - -Now all commands such as ``pip`` and ``python`` will use this activated virtual -environment. You can install the Python development dependencies using: - -.. code-block:: bash - - pip install -r requirements-dev.txt - -This will install the dependencies such as ``cython``, ``meson``, etc that are -needed for building and developing ``python-flint`` into the activated virtual -environment. - -The first step in developing ``python-flint`` is to build it and the first step -in building it is to configure the build using ``meson setup`` (or ``spin -build``). If you have already installed ``FLINT`` system-wide then you can run: - -.. code-block:: bash - - meson setup build - -This will check the system for the dependencies needed to build -``python-flint`` such as ``FLINT`` and ``GMP`` and ``MPFR``. It will also check -for C compilers and for ``Cython``. If setup was successful then you can now -build ``python-flint`` with: - -.. code-block:: bash - - meson compile -C build - -By default, ``python-flint``'s build configuration will reject newer versions -of ``FLINT`` or ``Cython`` than the ones that are known to work. If you want to -override this behaviour (e.g. because you have ``FLINT`` or ``Cython`` from a -newer version or latest git) then you can pass the -``-Dflint_version_check=false`` option: - -.. code-block:: bash - - meson setup build -Dflint_version_check=false - -If you have installed the dependencies in a non-standard location then you -need to tell ``meson`` where to find them when running ``meson setup``. For -example, if you have installed ``FLINT`` in a directory called -``/some/dir/lib`` then you can run: - -.. code-block:: bash - - meson setup build \ - --pkg-config-path=/some/dir/lib/pkgconfig \ - -Dadd_flint_rpath=true - -This tells ``meson`` to look for the ``pkg-config`` files such as ``flint.pc`` -in the ``/some/dir/lib/pkgconfig`` directory and to add the ``/some/dir/lib`` -directory to the runtime library search path in the ``python-flint`` extension -modules. The ``add_flint_rpath`` option may not be needed depending on your OS. - -Usually it is not necessary to use ``meson`` directly as shown above becuase -the ``spin`` tool provides a frontend to ``meson`` that combines common steps. -The ``spin build`` command can be used to setup and build the project in one -step: - -.. code-block:: 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 - -Most ``spin`` commands are primarily a wrapper for some other command (not -necessarily a ``meson`` command) and will pass any additional arguments -through. In this case the ``-Dflint_version_check=false`` option is passed to -the ``meson setup`` command. - -The ``spin build`` command is the one case where it is recommended to use -``meson`` directly instead of using ``spin``. For some reason ``spin build`` -does not always configure the project correctly and so the recommended way is: - -.. code-block:: bash - - meson setup build -Dflint_version_check=false - spin build - -After an initial call to ``meson setup`` all subsequent tasks can use ``spin`` -which will automatically rebuild the project when needed. For example, to run -the tests you can run: - -.. code-block:: bash - - spin run python -m flint.test - -This will build or rebuild ``python-flint`` if necessary and then run the -tests. This is equivalent to installing ``python-flint`` and then running the -same command e.g.: - -.. code-block:: bash - - pip install . - python -m flint.test - -More generally the ``spin run`` command can be used to run any command in the -local build environment as if ``python-flint`` was installed. - - -Common development tasks ------------------------- - -The most common development task is to rebuild the project and run the tests -and there are a few ways to do this. The most straight-forward way is - -.. code-block:: bash - - spin test - -The ``spin test`` command will rebuild the project if necessary and then run -``pytest``. Additional arguments can be passed to ``pytest`` by using the -``--`` separator e.g.: - -.. code-block:: bash - - spin test -- -k test_name # run only tests that match 'test_name' - spin test -- --pdb # drop into the debugger on test failure - -Note though that there are two kinds of tests in ``python-flint``: - -1. The general tests in the ``flint/test`` directory. -2. The doctests in the docstrings throughout the codebase (and also in the - docs). - -The ``spin test`` command only runs the general tests but not the doctests. To -run both you can use ``python -m flint.test`` when ``python-flint`` is -installed but in the development environment you can use: - -.. code-block:: bash - - spin run python -m flint.test # run all tests and doctests - -The two most useful ``spin`` commands are: - -- ``meson setup build``: Configure the project. -- ``spin run python -m flint.test``: Run all tests and doctests. - -Other useful ``spin`` commands are: - -- ``spin build``: Build the project. -- ``spin test``: Run the general tests. -- ``spin run``: Run a command in the local build environment. -- ``spin python``: Start a Python shell in the local build environment. -- ``spin ipython``: Start an IPython shell in the local build environment. -- ``spin shell``: Start a system shell in the local build environment. -- ``spin docs``: Build the documentation. - -One other command is provided but not recommended for general development: - -- ``spin install``: Install the project editably in the active Python - environment. - -Sometimes it is useful to install the project editably but it can conflict with -other ``spin`` commands. The editable install uses the same ``build`` directory -as the ``spin`` install and so the normal ``spin`` way of doing things is not -compatible with the editable install. You can uninstall the editable install -using ``pip uninstall python-flint`` and then wipe the build directory: - -.. code-block:: bash - - rm -r build - -In future perhaps other ``spin`` commands could be added to ``python-flint``'s -``spin`` configuration. - - -Measuring code coverage ------------------------ - -To measure code coverage it is first necessary to build the Cython code with -coverage enabled. This can be done by passing the ``-Dcoverage=true`` option to -``meson setup`` or ``spin build``. Measuring coverage of Cython code does not -currently work with ``spin`` (`issue -`_). However ``python-flint`` -has a local coverage plugin that can be used to measure coverage of the Cython -code in ``python-flint``. There is a script ``bin/coverage.sh`` that can be -used for this. Its contents are: - -.. code-block:: bash - - spin build -Dcoverage=true - spin run -- coverage run -m flint.test - coverage report -m --sort=cover - coverage html - -Note that the setting ``-Dcoverage=true`` enables tracing in the Cython code. -This considerably slows down the build as well as making ``python-flint`` a -lot slower to run. The setting is persistent and so needs to be explicitly -disabled when no longer needed: - -.. code-block:: bash - - meson setup build -Dcoverage=false - -(Note that this is an example where ``spin build`` is not used because it does -not trigger a rebuild correctly for some reason unlike ``meson setup``.) - - -Building in release mode ------------------------- - -Another setting that is worth configuring is the build type. By default ``meson -setup`` configures a debug mode build which means that the C code is not fully -optimised by the compiler. If you want to measure the performance of -``python-flint`` then you should build in release mode: - -.. code-block:: bash - - meson setup build -Dbuildtype=release - -This will build the C code with full optimisations enabled. Note that building -in release mode takes longer than building in debug mode and so it is not -always convenient for development. As for the coverage setting, the build type -is persistent and so needs to be disabled explicitly when no longer needed: - -.. code-block:: bash - - meson setup build -Dbuildtype=debug - -Note that the build type setting here only applies when compiling the C code -that is generated from the Cython code. This has no effect on the optimisation -level that is used for FLINT or GMP or MPFR. Setting the build type to release -only reduces the overhead of the ``python-flint`` wrapper code (which may or -may not be significant depending on what is being timed). - - -Differences between meson and autotools ---------------------------------------- - -Some differences between ``meson`` and autotools are worth noting for the -benefit of those who are familiar with autotools but not ``meson``. Firstly, -the way that ``meson`` is intended to be used is that many different build -directories can be created like: - -.. code-block:: bash - - meson setup build-debug -Dbuildtype=debug - meson setup build-release -Dbuildtype=release - -This allows different configurations and builds to be kept simultaneously. What -this means though is that all subsequent commands must be told which build -directory to use e.g. ``meson compile -C build-debug``. - -The ``meson configure`` command can be used to view or change the configuration -of a build directory: - -.. code-block:: bash - - meson configure build-debug # view the configuration - meson configure build-debug -Dsome_option=true # change the configuration - -It is expected that ``meson setup`` would only be called once per build -directory and that ``meson configure`` would be used to change the -configuration of an existing build directory: - -.. code-block:: bash - - meson setup build - meson configure build -Dsome_option=true -Dsome_other_option=false - -It is still possible to run ``meson setup`` multiple times (and does work) but -``meson`` complains (needlessly) that the directory is already configured: - -.. code-block:: console - - $ 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. - -Unlike an autotools ``./configure`` script the configuration options passed to -``meson setup`` are persistent and are combined in repeated calls: - -.. code-block:: bash - - meson setup build -Dfirst_option=true - meson setup build -Dsecond_option=false # first_option is still true - -With ``meson`` all generated files are placed in the build directory and the -source directory is kept clean. This means that rather than running e.g. ``make -clean`` you can just delete the build directory (``rm -r build``). Note that -the ``meson setup`` command has a ``--wipe`` option that will delete all of the -built files while keeping the configuration options: - -.. code-block:: bash - - meson setup build -Doption=true - ... - meson setup build --wipe # deletes all built files, option is still true diff --git a/meson.build b/meson.build deleted file mode 100644 index 16860da3..00000000 --- a/meson.build +++ /dev/null @@ -1,118 +0,0 @@ -project( - 'python-flint', - 'cython', - 'c', - meson_version : '>=1.3.0', - default_options: ['python.allow_limited_api=false'], -) -# -# The minimum versions are because we know that it will not work with earlier -# versions. The maximum versions are because python-flint was not tested -# against future versions that didn't exist at the time of release. In future -# if it seems like new releases do not always break the build of python-flint -# then we can consider not using a speculative upper version cap here. -# -flint_lower = '>=3.0' -flint_upper = '<3.4' -cython_lower = '>=3.0.11' -cython_upper = '<3.3' - -py = import('python').find_installation(pure: false) -dep_py = py.dependency() - -cc = meson.get_compiler('c') -cy = meson.get_compiler('cython') - -gmp_dep = dependency('gmp') -mpfr_dep = dependency('mpfr') -flint_dep = dependency('flint') - -# -# For the source release, we should by default fail for new untested versions -# with a clear error message about the version mismatch. -# -# We need an option to disable this though so that we can test newer versions -# of Flint. Also good to have an escape hatch for users since we don't know -# that future versions of Flint will not work. -# -ver_message = ''' - -Invalid @0@ version: -Version needed is: @0@ @2@, @3@ -Version found is: @0@ == @1@ - -By default, python-flint will only build against @0@ versions that have -been tested. If you are sure you want to use this version of @0@, you can -disable this check with -Dflint_version_check=false. - -If building from the source directory using meson directly, you can do this -with: - - meson setup build -Dflint_version_check=false - -If you are installing with pip, you can do this with: - - pip install --config-settings=setup-args="-Dflint_version_check=false" python-flint - -Other build frontends have similar options for passing this to meson. - -''' -if get_option('flint_version_check') - if not (flint_dep.version().version_compare(flint_lower) and - flint_dep.version().version_compare(flint_upper)) - error(ver_message.format('FLINT', flint_dep.version(), flint_lower, flint_upper)) - endif - if not (cy.version().version_compare(cython_lower) and - cy.version().version_compare(cython_upper)) - error(ver_message.format('Cython', cy.version(), cython_lower, cython_upper)) - endif -endif - -# flint.pc was missing -lflint until Flint 3.1.0 -if flint_dep.version().version_compare('<3.1') - flint_dep = cc.find_library('flint') - have_acb_theta = false -else - have_acb_theta = true -endif - -pyflint_deps = [dep_py, gmp_dep, mpfr_dep, flint_dep] - -add_project_arguments( - '-X', 'embedsignature=True', - '-X', 'emit_code_comments=True', - language : 'cython' -) - -# Only used if python.allow_limited_api is true (not the default) -limited_api_version = get_option('limited_api_version') - -# Enable free-threading if Cython is new enough. The check should be -# >= 3.1.0a1 but meson gets confused by the a1 alpha release suffix. -# so we go with >= 3.1 (which will be correct once 3.1 is released). -cy = meson.get_compiler('cython') -if get_option('python.allow_limited_api') - message('Using Python limited API version ' + limited_api_version) -elif cy.version().version_compare('>=3.1') - message('Enabling freethreading') - add_project_arguments('-Xfreethreading_compatible=true', language : 'cython') -else - message('Normal build (no freethreading and no limited API)') -endif - -if get_option('coverage') - add_project_arguments('-X', 'linetrace=True', language : 'cython') - add_project_arguments('-DCYTHON_TRACE=1', language : 'c') -endif - -# Add rpaths for a local build of flint found via pkgconfig -# https://github.com/mesonbuild/meson/issues/13046 -if get_option('add_flint_rpath') - flint_lib_dir = flint_dep.get_variable(pkgconfig: 'libdir') - add_project_link_arguments( - '-Wl,-rpath=' + flint_lib_dir, - language: 'c', - ) -endif - -subdir('src/flint') diff --git a/meson.options b/meson.options deleted file mode 100644 index d1094d31..00000000 --- a/meson.options +++ /dev/null @@ -1,4 +0,0 @@ -option('coverage', type : 'boolean', value : false, description : 'enable coverage build') -option('add_flint_rpath', type : 'boolean', value : false) -option('flint_version_check', type: 'boolean', value : true) -option('limited_api_version', type: 'string', value : '3.12') diff --git a/pyproject.toml b/pyproject.toml deleted file mode 100644 index 05aa589c..00000000 --- a/pyproject.toml +++ /dev/null @@ -1,175 +0,0 @@ -[project] -name = "python-flint" -description = "Bindings for FLINT" -version = "0.8.0" - -# This needs to be in sync with README, and CI config. -requires-python = ">= 3.11" -authors = [ - {name = "Fredrik Johansson", email = "fredrik.johansson@gmail.com"}, - {name = "Oscar Benjamin", email = "oscar.j.benjamin@gmail.com"}, -] - -license = "MIT" -license-files = ["LICENSE"] - -classifiers = [ - "Topic :: Scientific/Engineering :: Mathematics", -] - -[project.urls] -Homepage = "https://github.com/flintlib/python-flint" -Documentation = "https://python-flint.readthedocs.io/en/latest/" -Repository = "https://github.com/flintlib/python-flint" -Changelog = "https://github.com/flintlib/python-flint/blob/master/README.md#changelog" - -[project.readme] -file = "README.md" -content-type = "text/markdown" - -[build-system] -# -# Minimum build requirements tested in CI need to be kept in sync with the -# versions in requires below so that they are tested. -# -# To support the freethreaded build (CPython 3.13t) version 3.1.0 of Cython is -# needed as a minimum requirement. It is possible that future versions of -# Cython might still work but typically a Cython release breaks something in -# the build of python-flint so we include an upper bound here. -# -# Apart from the freethreading build any Cython version from 3.0.11 onwards is -# fine. It is not possible to have a separate version constraint here for the -# freethreading build only though. -# -requires = ["meson-python >= 0.18", "cython >=3.1,<3.3"] -build-backend = "mesonpy" - -[tool.meson-python] - -limited-api = true - -[tool.cython-lint] -# E129 visually indented line with same indent as next logical line -# Reasoning: this rule is a little controversial -# (see https://github.com/PyCQA/pycodestyle/issues/386) -# and we ignore it to avoid needing additional indentation after -# long logical statements. -# -# E501 line too long (128 > 120 characters) -# Reasoning: this is a work in progress and will be enforced once a line length -# and refactor has taken place. See issue #214 -# -# E741 ambiguous variable name -# Reasoning: many places it makes sense to use l or other letters as variable -# names as it is standard in mathematical notation. -max-line-length = 120 -ignore = ['E129','E501','E741'] -exclude = 'src/flint/flintlib/functions.*' - -[tool.spin] -package = "flint" - -[tool.spin.commands] - -"Build" = [ - "spin.cmds.meson.build", - "spin.cmds.meson.test", - "spin.cmds.build.sdist", - "spin.cmds.pip.install", -] -"Documentation" = [ - "spin.cmds.meson.docs", -] -"Environments" = [ - "spin.cmds.meson.shell", - "spin.cmds.meson.ipython", - "spin.cmds.meson.python", - "spin.cmds.meson.run", -] - -[tool.pytest.ini_options] -addopts = "--import-mode=importlib" - -[tool.cibuildwheel] -skip = "*-win32 *-manylinux_i686 *-manylinux_armv7l *-musllinux_*" - -enable = [ - # Uncomment this to test beta versions of CPython in CI (but comment out - # again if releasing while CPython is in beta): - # "cpython-prerelease", - "cpython-freethreading", - "pypy", -] - -manylinux-x86_64-image = "manylinux2014" -manylinux-aarch64-image = "manylinux_2_28" -manylinux-i686-image = "manylinux2014" - -[tool.cibuildwheel.linux.environment] -# LD_LIBRARY_PATH is needed by auditwheel -LD_LIBRARY_PATH = "$(pwd)/.local/lib:$LD_LIBRARY_PATH" -PKG_CONFIG_PATH = "$(pwd)/.local/lib/pkgconfig" - -[tool.cibuildwheel.macos.environment] -PKG_CONFIG_PATH = "$(pwd)/.local/lib/pkgconfig" - -[tool.cibuildwheel.windows.environment] -# Setting PKG_CONFIG_PATH here breaks pkgconfig for some reason... -# We set it in the CI workflow instead. -# PKG_CONFIG_PATH = "$(pwd)/.local/lib/pkgconfig:$PKG_CONFIG_PATH" - -[tool.cibuildwheel.linux] -before-all = "bin/cibw_before_all_linux_$(uname -m).sh" -before-build = "pip install wheel auditwheel" -repair-wheel-command = [ -"""bin/cibw_repair_wheel_licenses.py {wheel} \ - --license LGPL-3.0-or-later \ - --license-file '.local/src/gmp-*/COPYING:python-flint.libs/gmp-*/COPYING' \ - --license-file '.local/src/gmp-*/COPYING.LESSERv3:python-flint.libs/gmp-*/COPYING.LESSERv3' \ - --license-file '.local/src/mpfr-*/COPYING:python-flint.libs/mpfr-*/COPYING' \ - --license-file '.local/src/mpfr-*/COPYING.LESSER:python-flint.libs/mpfr-*/COPYING.LESSER' \ - --license-file '.local/src/flint-*/COPYING:python-flint.libs/flint-*/COPYING' \ - --license-file '.local/src/flint-*/COPYING.LESSER:python-flint.libs/flint-*/COPYING.LESSER' \ -""", -"auditwheel repair -w {dest_dir} {wheel}", -] - -[tool.cibuildwheel.macos] -before-all = "bin/cibw_before_all_macosx_$(uname -m).sh" -before-build = "pip install wheel delocate" -repair-wheel-command = [ -"""bin/cibw_repair_wheel_licenses.py {wheel} \ - --license LGPL-3.0-or-later \ - --license-file '.local/src/gmp-*/COPYING:python-flint.libs/gmp-*/COPYING' \ - --license-file '.local/src/gmp-*/COPYING.LESSERv3:python-flint.libs/gmp-*/COPYING.LESSERv3' \ - --license-file '.local/src/mpfr-*/COPYING:python-flint.libs/mpfr-*/COPYING' \ - --license-file '.local/src/mpfr-*/COPYING.LESSER:python-flint.libs/mpfr-*/COPYING.LESSER' \ - --license-file '.local/src/flint-*/COPYING:python-flint.libs/flint-*/COPYING' \ - --license-file '.local/src/flint-*/COPYING.LESSER:python-flint.libs/flint-*/COPYING.LESSER' \ -""", -"delocate-wheel --require-archs {delocate_archs} -w {dest_dir} -v {wheel}", -] - -[tool.cibuildwheel.windows] -before-all = "C:\\msys64\\usr\\bin\\bash bin/cibw_before_all_windows.sh" -before-build = "pip install wheel delvewheel" -repair-wheel-command = [ -"""python bin/cibw_repair_wheel_licenses.py {wheel} \ - --license LGPL-3.0-or-later \ - --license-file .local/src/gmp-*/COPYING:python-flint.libs/gmp-*/COPYING \ - --license-file .local/src/gmp-*/COPYING.LESSERv3:python-flint.libs/gmp-*/COPYING.LESSERv3 \ - --license-file .local/src/mpfr-*/COPYING:python-flint.libs/mpfr-*/COPYING \ - --license-file .local/src/mpfr-*/COPYING.LESSER:python-flint.libs/mpfr-*/COPYING.LESSER \ - --license-file .local/src/flint-*/COPYING:python-flint.libs/flint-*/COPYING \ - --license-file .local/src/flint-*/COPYING.LESSER:python-flint.libs/flint-*/COPYING.LESSER \ - \ - --license "MIT AND BSD-3-Clause-Clear" \ - --license-file wheels/winpthreads/COPYING:python-flint.libs/winpthreads/COPYING \ - \ - --license "GPL-3.0-or-later WITH GCC-exception-3.1 AND LGPL-2.1-or-later" \ - --license-file wheels/gcc/COPYING3:python-flint.libs/gcc/COPYING3 \ - --license-file wheels/gcc/COPYING.LIB:python-flint.libs/gcc/COPYING.LIB \ - --license-file wheels/gcc/COPYING.RUNTIME:python-flint.libs/gcc/COPYING.RUNTIME \ -""", -"delvewheel repair -w {dest_dir} {wheel} --add-path .local/bin", -] diff --git a/requirements-dev.txt b/requirements-dev.txt deleted file mode 100644 index 1ee3ec44..00000000 --- a/requirements-dev.txt +++ /dev/null @@ -1,11 +0,0 @@ -cython -ninja -spin -meson -meson-python -pytest -coverage -pytest-cov -sphinx -sphinx-rtd-theme -furo diff --git a/setup.py b/setup.py deleted file mode 100644 index 27163c17..00000000 --- a/setup.py +++ /dev/null @@ -1,148 +0,0 @@ -import sys -import os -from subprocess import check_call - -from Cython.Distutils import build_ext -from Cython.Build import cythonize - - -if sys.platform == 'win32' and sys.version_info < (3, 12): - from distutils.core import setup - from distutils.extension import Extension - from numpy.distutils.system_info import default_include_dirs, default_lib_dirs - from distutils.sysconfig import get_config_vars -else: - from setuptools import setup - from setuptools.extension import Extension - from sysconfig import get_config_vars - default_include_dirs = [] - default_lib_dirs = [] - - -libraries = ["flint"] - - -if sys.platform == 'win32': - # - # This is used in CI to build wheels with mingw64 - # - if os.getenv('PYTHON_FLINT_MINGW64'): - includedir = os.path.join(os.path.dirname(__file__), '.local', 'include') - librarydir1 = os.path.join(os.path.dirname(__file__), '.local', 'bin') - librarydir2 = os.path.join(os.path.dirname(__file__), '.local', 'lib') - librarydirs = [librarydir1, librarydir2] - default_include_dirs += [includedir] - default_lib_dirs += librarydirs - # Add gcc to the PATH in GitHub Actions when this setup.py is called by - # cibuildwheel. - os.environ['PATH'] += r';C:\msys64\mingw64\bin' - libraries += ["mpfr", "gmp"] - elif os.getenv('PYTHON_FLINT_MINGW64_TMP'): - # This would be used to build under Windows against these libraries if - # they have been installed somewhere other than .local - libraries += ["mpfr", "gmp"] - else: - # For the MSVC toolchain link with mpir instead of gmp - libraries += ["mpir", "mpfr", "pthreads"] -else: - libraries = ["flint"] - (opt,) = get_config_vars('OPT') - os.environ['OPT'] = " ".join(flag for flag in opt.split() if flag != '-Wstrict-prototypes') - - -define_macros = [] -compiler_directives = { - 'language_level': 3, - 'binding': False, -} - - -# Enable coverage tracing -if os.getenv('PYTHON_FLINT_COVERAGE'): - define_macros.append(('CYTHON_TRACE', 1)) - compiler_directives['linetrace'] = True - - -packages = [ - 'flint', - 'flint.flintlib', - 'flint.flint_base', - 'flint.types', - 'flint.functions', - 'flint.utils', - 'flint.test', -] - - -ext_files = [ - ("flint.pyflint", ["src/flint/pyflint.pyx"]), - - ("flint.flint_base.flint_base", ["src/flint/flint_base/flint_base.pyx"]), - ("flint.flint_base.flint_context", ["src/flint/flint_base/flint_context.pyx"]), - - ("flint.types.fmpz", ["src/flint/types/fmpz.pyx"]), - ("flint.types.fmpz_vec", ["src/flint/types/fmpz_vec.pyx"]), - ("flint.types.fmpz_poly", ["src/flint/types/fmpz_poly.pyx"]), - ("flint.types.fmpz_mpoly", ["src/flint/types/fmpz_mpoly.pyx"]), - ("flint.types.fmpz_mat", ["src/flint/types/fmpz_mat.pyx"]), - ("flint.types.fmpz_series", ["src/flint/types/fmpz_series.pyx"]), - - ("flint.types.fmpq", ["src/flint/types/fmpq.pyx"]), - ("flint.types.fmpq_vec", ["src/flint/types/fmpq_vec.pyx"]), - ("flint.types.fmpq_poly", ["src/flint/types/fmpq_poly.pyx"]), - ("flint.types.fmpq_mat", ["src/flint/types/fmpq_mat.pyx"]), - ("flint.types.fmpq_series", ["src/flint/types/fmpq_series.pyx"]), - - ("flint.types.nmod", ["src/flint/types/nmod.pyx"]), - ("flint.types.nmod_poly", ["src/flint/types/nmod_poly.pyx"]), - ("flint.types.nmod_mat", ["src/flint/types/nmod_mat.pyx"]), - ("flint.types.nmod_series", ["src/flint/types/nmod_series.pyx"]), - ("flint.types.nmod_mpoly", ["src/flint/types/nmod_mpoly.pyx"]), - - ("flint.types.fmpz_mod", ["src/flint/types/fmpz_mod.pyx"]), - ("flint.types.fmpz_mod_poly", ["src/flint/types/fmpz_mod_poly.pyx"]), - ("flint.types.fmpz_mod_mpoly", ["src/flint/types/fmpz_mod_mpoly.pyx"]), - ("flint.types.fmpz_mod_mat", ["src/flint/types/fmpz_mod_mat.pyx"]), - - ("flint.types.fmpq_mpoly", ["src/flint/types/fmpq_mpoly.pyx"]), - - ("flint.types.fq_default", ["src/flint/types/fq_default.pyx"]), - ("flint.types.fq_default_poly", ["src/flint/types/fq_default_poly.pyx"]), - - ("flint.types.arf", ["src/flint/types/arf.pyx"]), - ("flint.types.arb", ["src/flint/types/arb.pyx"]), - ("flint.types.arb_poly", ["src/flint/types/arb_poly.pyx"]), - ("flint.types.arb_mat", ["src/flint/types/arb_mat.pyx"]), - ("flint.types.arb_series", ["src/flint/types/arb_series.pyx"]), - ("flint.types.acb", ["src/flint/types/acb.pyx"]), - ("flint.types.acb_poly", ["src/flint/types/acb_poly.pyx"]), - ("flint.types.acb_mat", ["src/flint/types/acb_mat.pyx"]), - ("flint.types.acb_series", ["src/flint/types/acb_series.pyx"]), - - ("flint.types.dirichlet", ["src/flint/types/dirichlet.pyx"]), - - ("flint.functions.showgood", ["src/flint/functions/showgood.pyx"]), -] - -ext_options = { - "libraries" : libraries, - "library_dirs" : default_lib_dirs, - "include_dirs" : default_include_dirs, - "define_macros" : define_macros, -} - -ext_modules = [] -for mod_name, src_files in ext_files: - ext = Extension(mod_name, src_files, **ext_options) - ext_modules.append(ext) - -for e in ext_modules: - e.cython_directives = {"embedsignature": True} - - -setup( - cmdclass={'build_ext': build_ext}, - ext_modules=cythonize(ext_modules, compiler_directives=compiler_directives), - packages=packages, - package_dir={'': 'src'}, -) diff --git a/src/flint/__init__.py b/src/flint/__init__.py deleted file mode 100644 index 1401e17c..00000000 --- a/src/flint/__init__.py +++ /dev/null @@ -1,107 +0,0 @@ -from .pyflint import ctx - -from .types.fmpz import fmpz -from .types.fmpz_poly import fmpz_poly -from .types.fmpz_mat import fmpz_mat -from .types.fmpz_series import fmpz_series -from .types.fmpz_vec import fmpz_vec - -from .types.fmpq import fmpq -from .types.fmpq_poly import fmpq_poly -from .types.fmpq_mat import fmpq_mat -from .types.fmpq_series import fmpq_series -from .types.fmpq_vec import fmpq_vec - -from .types.nmod import nmod -from .types.nmod_poly import nmod_poly -from .types.nmod_mpoly import nmod_mpoly_ctx, nmod_mpoly, nmod_mpoly_vec -from .types.nmod_mat import nmod_mat -from .types.nmod_series import nmod_series - -from .types.fmpz_mpoly import fmpz_mpoly_ctx, fmpz_mpoly, fmpz_mpoly_vec -from .types.fmpz_mod import fmpz_mod, fmpz_mod_ctx -from .types.fmpz_mod_poly import fmpz_mod_poly, fmpz_mod_poly_ctx -from .types.fmpz_mod_mpoly import fmpz_mod_mpoly_ctx, fmpz_mod_mpoly, fmpz_mod_mpoly_vec -from .types.fmpz_mod_mat import fmpz_mod_mat - -from .types.fmpq_mpoly import fmpq_mpoly_ctx, fmpq_mpoly, fmpq_mpoly_vec - -from .types.fq_default import fq_default, fq_default_ctx -from .types.fq_default_poly import fq_default_poly, fq_default_poly_ctx - -from .types.arf import arf -from .types.arb import arb -from .types.arb_poly import arb_poly -from .types.arb_mat import arb_mat -from .types.arb_series import arb_series -from .types.acb import acb -from .types.acb_poly import acb_poly -from .types.acb_mat import acb_mat -from .types.acb_series import acb_series - -from .types.dirichlet import dirichlet_char, dirichlet_group -from .functions.showgood import good, showgood - -from .flint_base.flint_base import ( - FLINT_VERSION as __FLINT_VERSION__, - FLINT_RELEASE as __FLINT_RELEASE__, - Ordering, -) - -__version__ = "0.8.0" - -__all__ = [ - "ctx", - "fmpz", - "fmpz_poly", - "fmpz_mat", - "fmpz_series", - "fmpz_vec", - "fmpq", - "fmpq_poly", - "fmpq_mat", - "fmpq_series", - "fmpq_vec", - "nmod", - "nmod_poly", - "nmod_mpoly_ctx", - "nmod_mpoly", - "nmod_mpoly_vec", - "nmod_mat", - "nmod_series", - "fmpz_mpoly_ctx", - "fmpz_mpoly", - "fmpz_mpoly_vec", - "fmpz_mod", - "fmpz_mod_ctx", - "fmpz_mod_poly", - "fmpz_mod_poly_ctx", - "fmpz_mod_mpoly_ctx", - "fmpz_mod_mpoly", - "fmpz_mod_mpoly_vec", - "fmpz_mod_mat", - "fmpq_mpoly_ctx", - "fmpq_mpoly", - "fmpq_mpoly_vec", - "fq_default", - "fq_default_ctx", - "fq_default_poly", - "fq_default_poly_ctx", - "arf", - "arb", - "arb_poly", - "arb_mat", - "arb_series", - "acb", - "acb_poly", - "acb_mat", - "acb_series", - "dirichlet_char", - "dirichlet_group", - "good", - "showgood", - "Ordering", - "__FLINT_VERSION__", - "__FLINT_RELEASE__", - "__version__", -] diff --git a/src/flint/flint_base/__init__.py b/src/flint/flint_base/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/flint_base/flint_base.pxd b/src/flint/flint_base/flint_base.pxd deleted file mode 100644 index 53d624db..00000000 --- a/src/flint/flint_base/flint_base.pxd +++ /dev/null @@ -1,66 +0,0 @@ -from flint.flintlib.types.mpoly cimport ordering_t -from flint.flintlib.types.flint cimport slong - -cdef class flint_ctx: - pass - -cdef class flint_elem: - pass - -cdef class flint_scalar(flint_elem): - pass - -cdef class flint_poly(flint_elem): - pass - -cdef class flint_mpoly_context(flint_elem): - cdef public object py_names - cdef const char ** c_names - -cdef class flint_mod_mpoly_context(flint_mpoly_context): - cdef readonly bint __prime_modulus - -cdef class flint_mpoly(flint_elem): - cdef _add_scalar_(self, other) - cdef _sub_scalar_(self, other) - cdef _mul_scalar_(self, other) - - cdef _add_mpoly_(self, other) - cdef _sub_mpoly_(self, other) - cdef _mul_mpoly_(self, other) - - cdef _divmod_mpoly_(self, other) - cdef _truediv_scalar_(self, other) - cdef _divexact_scalar_(self, other) - cdef _floordiv_mpoly_(self, other) - cdef _truediv_mpoly_(self, other) - cdef _mod_mpoly_(self, other) - - cdef _rsub_scalar_(self, other) - cdef _rsub_mpoly_(self, other) - - cdef _rdivmod_mpoly_(self, other) - cdef _rfloordiv_mpoly_(self, other) - cdef _rtruediv_mpoly_(self, other) - cdef _rmod_mpoly_(self, other) - - cdef _pow_(self, other) - - cdef _iadd_scalar_(self, other) - cdef _isub_scalar_(self, other) - cdef _imul_scalar_(self, other) - - cdef _iadd_mpoly_(self, other) - cdef _isub_mpoly_(self, other) - cdef _imul_mpoly_(self, other) - - cdef _compose_gens_(self, ctx, slong *mapping) - -cdef class flint_mat(flint_elem): - pass - -cdef class flint_series(flint_elem): - pass - -cdef ordering_t ordering_py_to_c(ordering) -cdef ordering_c_to_py(ordering_t ordering) diff --git a/src/flint/flint_base/flint_base.pyi b/src/flint/flint_base/flint_base.pyi deleted file mode 100644 index df189363..00000000 --- a/src/flint/flint_base/flint_base.pyi +++ /dev/null @@ -1,202 +0,0 @@ -# -# -# -from typing import ( - Generic, - TypeVar, - Iterator, - Iterable, - Any, - Final, - Self, - Mapping, - Sequence, - overload, -) -from abc import abstractmethod -import enum - -FLINT_VERSION: Final[str] -FLINT_RELEASE: Final[int] - -Telem = TypeVar("Telem", bound=flint_scalar) -Telem_coerce = TypeVar("Telem_coerce", contravariant=True) -Tmpoly = TypeVar("Tmpoly", bound=flint_mpoly) -Tctx = TypeVar("Tctx", bound=flint_mpoly_context) - -Sctx = TypeVar("Sctx", bound=flint_mpoly_context) - -_str = str - -class flint_elem: - def str(self) -> _str: ... - def repr(self) -> _str: ... - -class flint_scalar(flint_elem): - def is_zero(self) -> bool: ... - def __pos__(self) -> Self: ... - def __neg__(self) -> Self: ... - def __add__(self, other: int, /) -> Self: ... - def __radd__(self, other: int, /) -> Self: ... - def __sub__(self, other: int, /) -> Self: ... - def __rsub__(self, other: int, /) -> Self: ... - def __mul__(self, other: int, /) -> Self: ... - def __rmul__(self, other: int, /) -> Self: ... - def __truediv__(self, other: int, /) -> Self: ... - def __rtruediv__(self, other: int, /) -> Self: ... - def __pow__(self, other: int, /) -> Self: ... - def __rpow__(self, other: int, /) -> Self: ... - -class flint_poly(flint_elem, Generic[Telem]): - def str( - self, ascending: bool = False, var: str = "x", *args: Any, **kwargs: Any - ) -> str: ... - def __iter__(self) -> Iterator[Telem]: ... - def __getitem__(self, index: int, /) -> Telem: ... - def __setitem__(self, index: int, value: Telem | int, /) -> None: ... - def __len__(self) -> int: ... - def length(self) -> int: ... - def degree(self) -> int: ... - def coeffs(self) -> list[Telem]: ... - def __call__(self, other: Telem | int, /) -> Telem: ... - def __pos__(self) -> Self: ... - def __neg__(self) -> Self: ... - def __add__(self, other: Telem | int, /) -> Self: ... - def __radd__(self, other: Telem | int, /) -> Self: ... - def __sub__(self, other: Telem | int, /) -> Self: ... - def __rsub__(self, other: Telem | int, /) -> Self: ... - def __mul__(self, other: Telem | int, /) -> Self: ... - def __rmul__(self, other: Telem | int, /) -> Self: ... - def __truediv__(self, other: Telem | int, /) -> Self: ... - def __rtruediv__(self, other: Telem | int, /) -> Self: ... - def __floordiv__(self, other: Telem | int, /) -> Self: ... - def __rfloordiv__(self, other: Telem | int, /) -> Self: ... - def __mod__(self, other: Telem | int, /) -> Self: ... - def __rmod__(self, other: Telem | int, /) -> Self: ... - def __divmod__(self, other: Telem | int, /) -> tuple[Self, Self]: ... - def __rdivmod__(self, other: Telem | int, /) -> tuple[Self, Self]: ... - def __pow__(self, other: int, /) -> Self: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_constant(self) -> bool: ... - def is_gen(self) -> bool: ... - def roots(self) -> list[tuple[Telem, int]]: ... - # Should be list[arb]: - def real_roots(self) -> list[Any]: ... - # Should be list[acb]: - def complex_roots(self) -> list[Any]: ... - def derivative(self) -> Self: ... - -class Ordering(enum.Enum): - lex = "lex" - deglex = "deglex" - degrevlex = "degrevlex" - -class flint_mpoly(flint_elem, Generic[Tctx, Telem, Telem_coerce]): - def __init__( - self, - val: Self - | Telem - | Telem_coerce - | int - | dict[tuple[int, ...], Telem | Telem_coerce | int] - | str = 0, - ctx: Tctx | None = None, - ) -> None: ... - def str(self) -> _str: ... - def repr(self) -> _str: ... - def context(self) -> Tctx: ... - def degrees(self) -> tuple[int, ...]: ... - def total_degree(self) -> int: ... - def leading_coefficient(self) -> Telem: ... - def to_dict(self) -> dict[tuple[int, ...], Telem]: ... - def is_one(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_constant(self) -> bool: ... - def __len__(self) -> int: ... - def __getitem__(self, index: tuple[int, ...]) -> Telem: ... - def __setitem__( - self, index: tuple[int, ...], coeff: Telem | Telem_coerce | int - ) -> None: ... - def __iter__(self) -> Iterable[tuple[int, ...]]: ... - def __contains__(self, index: tuple[int, ...]) -> bool: ... - def coefficient(self, i: int) -> Telem: ... - def monomial(self, i: int) -> tuple[int, ...]: ... - def terms(self) -> Iterable[tuple[tuple[int, ...], Telem]]: ... - def monoms(self) -> list[tuple[int, ...]]: ... - def coeffs(self) -> list[Telem]: ... - def __pos__(self) -> Self: ... - def __neg__(self) -> Self: ... - def __add__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __radd__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __sub__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __rsub__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __mul__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __rmul__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __truediv__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __rtruediv__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __floordiv__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __rfloordiv__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __mod__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __rmod__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __divmod__( - self, other: Telem | Telem_coerce | int - ) -> tuple[Self, Self]: ... - def __rdivmod__(self, other: Telem | Telem_coerce | int) -> tuple[Self, Self]: ... - def __pow__(self, other: Telem | Telem_coerce | int) -> Self: ... - def __rpow__(self, other: Telem | Telem_coerce | int) -> Self: ... - def iadd(self, other: Telem | Telem_coerce | int) -> None: ... - def isub(self, other: Telem | Telem_coerce | int) -> None: ... - def imul(self, other: Telem | Telem_coerce | int) -> None: ... - def term_content(self) -> Self: ... - def factor(self) -> tuple[Telem, Sequence[tuple[Self, int]]]: ... - def factor_squarefree(self) -> tuple[Telem, Sequence[tuple[Self, int]]]: ... - def sqrt(self) -> Self: ... - def discriminant(self, var: _str | int) -> Self: ... - def deflation_index(self) -> tuple[list[int], list[int]]: ... - def deflation(self) -> tuple[Self, list[int]]: ... - def deflation_monom(self) -> tuple[Self, list[int], Self]: ... - def inflate(self, N: list[int]) -> Self: ... - def deflate(self, N: list[int]) -> Self: ... - def subs(self, mapping: dict[_str | int, Telem | Telem_coerce | int]) -> Self: ... - def __call__(self, *args: Telem | Telem_coerce) -> Telem: ... - def derivative(self, var: _str | int) -> Self: ... - def unused_gens(self) -> tuple[_str, ...]: ... - def project_to_context( - self, other_ctx: Tctx, mapping: dict[_str | int, _str | int] | None = None - ) -> Self: ... - -class flint_mpoly_context(flint_elem, Generic[Tmpoly, Telem, Telem_coerce]): - def nvars(self) -> int: ... - def ordering(self) -> Ordering: ... - def gen(self, i: int, /) -> Tmpoly: ... - def from_dict(self, d: Mapping[tuple[int, ...], Telem_coerce], /) -> Tmpoly: ... - def constant(self, z: Telem_coerce, /) -> Tmpoly: ... - def name(self, i: int, /) -> str: ... - def names(self) -> tuple[str, ...]: ... - def gens(self) -> tuple[Tmpoly, ...]: ... - def variable_to_index(self, var: str, /) -> int: ... - def term( - self, coeff: Telem_coerce | None = None, exp_vec: Iterable[int] | None = None - ) -> Tmpoly: ... - def drop_gens(self, gens: Iterable[str | int], /) -> Self: ... - def append_gens(self, gens: Iterable[str | int], /) -> Self: ... - def infer_generator_mapping( - self, ctx: flint_mpoly_context, / - ) -> dict[int, int]: ... - @classmethod - def from_context( - cls, - ctx: flint_mpoly_context, - names: str | Iterable[str | tuple[str, int]] | tuple[str, int] | None = None, - ordering: Ordering | str = Ordering.lex, - ) -> Self: ... - -class flint_mod_mpoly_context(flint_mpoly_context[Tmpoly, Telem, Telem_coerce]): - @abstractmethod - def modulus(self): ... - -class flint_series(flint_elem, Generic[Telem]): - """Base class for power series.""" - def __iter__(self) -> Iterator[Telem]: ... - def coeffs(self) -> list[Telem]: ... diff --git a/src/flint/flint_base/flint_base.pyx b/src/flint/flint_base/flint_base.pyx deleted file mode 100644 index 375486dc..00000000 --- a/src/flint/flint_base/flint_base.pyx +++ /dev/null @@ -1,1088 +0,0 @@ -from flint.flintlib.types.flint cimport ( - FLINT_BITS as _FLINT_BITS, - FLINT_VERSION as _FLINT_VERSION, - __FLINT_RELEASE as _FLINT_RELEASE, - slong, -) -from flint.utils.flint_exceptions import DomainError -from flint.flintlib.types.mpoly cimport ordering_t -from flint.flintlib.functions.fmpz cimport fmpz_cmp_si -from flint.flint_base.flint_context cimport thectx -from flint.utils.typecheck cimport typecheck -cimport libc.stdlib - -from collections.abc import Iterable -from flint.utils.flint_exceptions import IncompatibleContextError - -from flint.types.fmpz cimport fmpz, any_as_fmpz - -import enum - -FLINT_BITS = _FLINT_BITS -FLINT_VERSION = _FLINT_VERSION.decode("ascii") -FLINT_RELEASE = _FLINT_RELEASE - - -cdef class flint_elem: - def __repr__(self): - if thectx.pretty: - return self.str() - else: - return self.repr() - - def __str__(self): - return self.str() - - -cdef class flint_scalar(flint_elem): - # ================================================= - # These are the functions a new class should define - # assumes that addition and multiplication are - # commutative - # ================================================= - def is_zero(self): - return False - - def _any_as_self(self, other): - return NotImplemented - - def _neg_(self): - return NotImplemented - - def _add_(self, other): - return NotImplemented - - def _sub_(self, other): - return NotImplemented - - def _rsub_(self, other): - return NotImplemented - - def _mul_(self, other): - return NotImplemented - - def _div_(self, other): - return NotImplemented - - def _rdiv_(self, other): - return NotImplemented - - def _floordiv_(self, other): - return NotImplemented - - def _rfloordiv_(self, other): - return NotImplemented - - def _invert_(self): - return NotImplemented - - # ================================================= - # Generic arithmetic using the above functions - # ================================================= - - def __pos__(self): - return self - - def __neg__(self): - return self._neg_() - - def __add__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._add_(other) - - def __radd__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._add_(other) - - def __sub__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._sub_(other) - - def __rsub__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._rsub_(other) - - def __mul__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._mul_(other) - - def __rmul__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._mul_(other) - - def __truediv__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - - if other.is_zero(): - raise ZeroDivisionError - - return self._div_(other) - - def __rtruediv__(self, other): - if self.is_zero(): - raise ZeroDivisionError - - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._rdiv_(other) - - def __floordiv__(self, other): - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - - if other.is_zero(): - raise ZeroDivisionError - - return self._floordiv_(other) - - def __rfloordiv__(self, other): - if self.is_zero(): - raise ZeroDivisionError - - other = self._any_as_self(other) - if other is NotImplemented: - return NotImplemented - return self._rfloordiv_(other) - - def __invert__(self): - if self.is_zero(): - raise ZeroDivisionError - return self._invert_() - - -cdef class flint_poly(flint_elem): - """ - Base class for polynomials. - """ - - def __iter__(self): - cdef long i, n - n = self.length() - for i in range(n): - yield self[i] - - def coeffs(self): - """ - Returns the coefficients of ``self`` as a list - - >>> from flint import fmpz_poly - >>> f = fmpz_poly([1,2,3,4,5]) - >>> f.coeffs() - [1, 2, 3, 4, 5] - """ - return list(self) - - def str(self, bint ascending=False, var="x", *args, **kwargs): - """ - Convert to a human-readable string (generic implementation for - all polynomial types). - - If *ascending* is *True*, the monomials are output from low degree to - high, otherwise from high to low. - """ - coeffs = [c.str(*args, **kwargs) for c in self] - if not coeffs: - return "0" - s = [] - coeffs = enumerate(coeffs) - if not ascending: - coeffs = reversed(list(coeffs)) - for i, c in coeffs: - if c == "0": - continue - else: - if c.startswith("-") or (" " in c): - c = "(" + c + ")" - if i == 0: - s.append("%s" % c) - elif i == 1: - if c == "1": - s.append(var) - else: - s.append(f"{c}*{var}") - else: - if c == "1": - s.append(f"{var}^{i}") - else: - s.append(f"{c}*{var}^{i}") - return " + ".join(s) - - def roots(self): - """ - Computes all the roots in the base ring of the polynomial. - Returns a list of all pairs (*v*, *m*) where *v* is the - integer root and *m* is the multiplicity of the root. - - To compute complex roots of a polynomial, instead use - the ``.complex_roots()`` method, which is available on - certain polynomial rings. - - >>> from flint import fmpz_poly - >>> fmpz_poly([1, 2]).roots() - [] - >>> fmpz_poly([2, 1]).roots() - [(-2, 1)] - >>> fmpz_poly([12, 7, 1]).roots() - [(-3, 1), (-4, 1)] - >>> (fmpz_poly([-5,1]) * fmpz_poly([-5,1]) * fmpz_poly([-3,1])).roots() - [(3, 1), (5, 2)] - """ - factor_fn = getattr(self, "factor", None) - if not callable(factor_fn): - raise NotImplementedError("Polynomial has no factor method, roots cannot be determined") - - roots = [] - factors = self.factor() - for fac, m in factors[1]: - if fac.degree() == 1: - try: - v = - fac[0] / fac[1] - except DomainError: - pass - else: - roots.append((v, m)) - return roots - - def real_roots(self): - raise NotImplementedError("Real roots are not supported for this polynomial") - - def complex_roots(self): - raise NotImplementedError("Complex roots are not supported for this polynomial") - - -class Ordering(enum.Enum): - lex = "lex" - deglex = "deglex" - degrevlex = "degrevlex" - - -cdef ordering_t ordering_py_to_c(ordering): - if ordering == Ordering.lex: - return ordering_t.ORD_LEX - elif ordering == Ordering.deglex: - return ordering_t.ORD_DEGLEX - elif ordering == Ordering.degrevlex: - return ordering_t.ORD_DEGREVLEX - -cdef ordering_c_to_py(ordering_t ordering): - if ordering == ordering_t.ORD_LEX: - return Ordering.lex - elif ordering == ordering_t.ORD_DEGLEX: - return Ordering.deglex - elif ordering == ordering_t.ORD_DEGREVLEX: - return Ordering.degrevlex - else: - raise ValueError("unimplemented term order %d" % ordering) - - -cdef class flint_mpoly_context(flint_elem): - """ - Base class for multivariate ring contexts - """ - - _ctx_cache = None - - def __init__(self, *_, **_2): - raise RuntimeError( - f"{self.__class__.__name__} should not be constructed directly. " - f"Use '{self.__class__.__name__}.get' instead." - ) - - @classmethod - def _new_(_, flint_mpoly_context self, names: Iterable[str]): - """ - Constructor for all mpoly context types. This method is not intended for - user-face use. See ``get`` instead. - - Construction via ``__init__`` is disabled to prevent the accidental creation of - new mpoly contexts. By ensuring each context is unique they can be compared via - pointer comparisons. - - Each concrete subclass should maintain their own context cache in - ``_ctx_cache``, and the ``get`` method should insert newly created contexts into - the cache. - """ - self.py_names = tuple(name.encode("ascii") if not isinstance(name, bytes) else name for name in names) - self.c_names = libc.stdlib.malloc(len(names) * sizeof(const char *)) - for i in range(len(names)): - self.c_names[i] = self.py_names[i] - return self - - def __dealloc__(self): - libc.stdlib.free(self.c_names) - self.c_names = NULL - - def __str__(self): - return self.__repr__() - - def __repr__(self): - return f"{self.__class__.__name__}({self.nvars()}, '{repr(self.ordering())}', {self.names()})" - - def name(self, i: int): - if not 0 <= i < len(self.py_names): - raise IndexError("variable name index out of range") - return self.py_names[i].decode("ascii") - - def names(self) -> tuple[str]: - return tuple(name.decode("ascii") for name in self.py_names) - - def gens(self): - return tuple(self.gen(i) for i in range(self.nvars())) - - def variable_to_index(self, var: Union[int, str]) -> int: - """ - Convert a variable name string or possible index to its index in the context. - - If ``var`` is negative, return the index of the ``self.nvars() + var`` - """ - if isinstance(var, str): - try: - i = self.names().index(var) - except ValueError: - raise ValueError("variable not in context") - elif isinstance(var, int): - if var < 0: - var = self.nvars() + var - - if not 0 <= var < self.nvars(): - raise IndexError("generator index out of range") - i = var - else: - raise TypeError("invalid variable type") - - return i - - @staticmethod - def create_variable_names(names: str | Iterable[str | tuple[str, int]]) -> tuple[str]: - """ - Create a tuple of variable names based off either ``str``, ``Iterable[str]``, - ``tuple[str, int]``, or ``Iterable[tuple[str, int]]``. - - >>> flint_mpoly_context.create_variable_names('x') - ('x',) - >>> flint_mpoly_context.create_variable_names(('x', 3)) - ('x0', 'x1', 'x2') - >>> flint_mpoly_context.create_variable_names([('x', 3), 'y']) - ('x0', 'x1', 'x2', 'y') - """ - res: list[str] = [] - - # To avoid having to pass a nested tuple we allow a tuple[str, int] - if len(names) == 2 and isinstance(names[0], str) and isinstance(names[1], int): - names = (names,) - - for name in names: - if isinstance(name, (str, bytes)): - res.append(name) - else: - base, num = name - if num < 0: - raise ValueError("cannot create a negative number of variables") - res.extend(base + str(i) for i in range(num)) - - return tuple(res) - - @classmethod - def create_context_key( - cls, - names: str | Iterable[str | tuple[str, int]], - ordering: Ordering | str = Ordering.lex - ): - """ - Create a key for the context cache via the variable names and the ordering. - """ - return cls.create_variable_names(names), Ordering(ordering) if not isinstance(ordering, Ordering) else ordering - - @classmethod - def get(cls, *args, **kwargs): - """ - Retrieve or create a context via generator names, ``names`` and the ordering, ``ordering``. - - See ``create_variable_names`` for naming schemes. - """ - key = cls.create_context_key(*args, **kwargs) - - ctx = cls._ctx_cache.get(key) - if ctx is None: - ctx = cls._ctx_cache.setdefault(key, cls._new_(*key)) - return ctx - - @classmethod - def from_context(cls, ctx: flint_mpoly_context, names=None, ordering=None): - """ - Get a new context from an existing one. Optionally override ``names`` or - ``ordering``. - """ - return cls.get( - names=ctx.names() if names is None else names, - ordering=ctx.ordering() if ordering is None else ordering, - ) - - def _any_as_scalar(self, other): - raise NotImplementedError("abstract method") - - def _scalar_as_mpoly(self, other): - raise NotImplementedError("abstract method") - - def compatible_context_check(self, other): - if not typecheck(other, type(self)): - raise TypeError(f"type {type(other)} is not {type(self)}") - elif other is not self: - raise IncompatibleContextError(f"{other} is not {self}") - - def term(self, coeff = None, exp_vec = None): - """ - Create a monomial from a coefficient and exponent vector. ``coeff`` defaults - to ``1``. ``exp_vec``` defaults to ``(0,) * self.nvars()```. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> ctx.term(coeff=5, exp_vec=(2, 3)) - 5*x0^2*x1^3 - >>> ctx.term() - 1 - """ - if coeff is None: - coeff = 1 - if exp_vec is None: - exp_vec = (0,) * self.nvars() - return self.from_dict({tuple(exp_vec): coeff}) - - def drop_gens(self, gens: Iterable[str | int]): - """ - Get a context with the specified generators removed. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y', 'z', 'a', 'b')) - >>> ctx.drop_gens(('x', -2)) - fmpz_mpoly_ctx(3, '', ('y', 'z', 'b')) - """ - nvars = self.nvars() - gen_idxs = {self.variable_to_index(i) for i in gens} - - if len(gens) > nvars: - raise ValueError(f"expected at most {nvars} unique generators, got {len(gens)}") - - names = self.names() - remaining_gens = [] - for i in range(nvars): - if i not in gen_idxs: - remaining_gens.append(names[i]) - - return self.from_context(self, names=remaining_gens) - - def append_gens(self, *gens: str): - """ - Get a context with the specified generators appended. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y', 'z')) - >>> ctx.append_gens('a', 'b') - fmpz_mpoly_ctx(5, '', ('x', 'y', 'z', 'a', 'b')) - """ - return self.from_context(self, names=self.names() + gens) - - def infer_generator_mapping(self, ctx: flint_mpoly_context): - """ - Infer a mapping of generator indexes from this contexts generators, to the - provided contexts generators. Inference is done based upon generator names. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y', 'z', 'a', 'b')) - >>> ctx2 = fmpz_mpoly_ctx.get(('b', 'a')) - >>> mapping = ctx.infer_generator_mapping(ctx2) - >>> mapping # doctest: +SKIP - {3: 1, 4: 0} - >>> list(sorted(mapping.items())) # Set ordering is not stable - [(3, 1), (4, 0)] - """ - gens_to_idxs = {x: i for i, x in enumerate(self.names())} - other_gens_to_idxs = {x: i for i, x in enumerate(ctx.names())} - return { - gens_to_idxs[k]: other_gens_to_idxs[k] - for k in (gens_to_idxs.keys() & other_gens_to_idxs.keys()) - } - - -cdef class flint_mod_mpoly_context(flint_mpoly_context): - @classmethod - def _new_(_, flint_mod_mpoly_context self, names, prime_modulus): - super()._new_(self, names) - self.__prime_modulus = prime_modulus - - return self - - @classmethod - def create_context_key( - cls, - names: Iterable[str | tuple[str, int]], - modulus, - ordering: Ordering | str = Ordering.lex - ): - """ - Create a key for the context cache via the variable names, modulus, and the ordering. - """ - return *super().create_context_key(names, ordering), modulus - - @classmethod - def from_context(cls, ctx: flint_mod_mpoly_context, names=None, ordering=None, modulus=None): - """ - Get a new context from an existing one. Optionally override ``names``, - ``modulus``, or ``ordering``. - """ - return cls.get( - names=ctx.names() if names is None else names, - modulus=ctx.modulus() if modulus is None else modulus, - ordering=ctx.ordering() if ordering is None else ordering, - ) - - def is_prime(self): - """ - Return whether the modulus is prime - - >>> from flint import fmpz_mod_mpoly_ctx - >>> ctx = fmpz_mod_mpoly_ctx.get(('z',), 2**127, 'degrevlex') - >>> ctx.is_prime() - False - >>> ctx = fmpz_mod_mpoly_ctx.get(('z',), 2**127 - 1, 'degrevlex') - >>> ctx.is_prime() - True - """ - return self.__prime_modulus - - -cdef class flint_mpoly(flint_elem): - """ - Base class for multivariate polynomials. - """ - - def leading_coefficient(self): - return self.coefficient(0) - - def to_dict(self): - return {self.monomial(i): self.coefficient(i) for i in range(len(self))} - - def _division_check(self, other): - if not other: - raise ZeroDivisionError(f"{self.__class__.__name__} division by zero") - - cdef _add_scalar_(self, other): - return NotImplemented - - cdef _sub_scalar_(self, other): - return NotImplemented - - cdef _mul_scalar_(self, other): - return NotImplemented - - cdef _add_mpoly_(self, other): - return NotImplemented - - cdef _sub_mpoly_(self, other): - return NotImplemented - - cdef _mul_mpoly_(self, other): - return NotImplemented - - cdef _divmod_mpoly_(self, other): - return NotImplemented - - cdef _floordiv_mpoly_(self, other): - return NotImplemented - - cdef _truediv_scalar_(self, other): - return NotImplemented - - cdef _divexact_scalar_(self, other): - return NotImplemented - - cdef _truediv_mpoly_(self, other): - return NotImplemented - - cdef _mod_mpoly_(self, other): - return NotImplemented - - cdef _rsub_scalar_(self, other): - return NotImplemented - - cdef _rsub_mpoly_(self, other): - return NotImplemented - - cdef _rdivmod_mpoly_(self, other): - return NotImplemented - - cdef _rfloordiv_mpoly_(self, other): - return NotImplemented - - cdef _rtruediv_mpoly_(self, other): - return NotImplemented - - cdef _rmod_mpoly_(self, other): - return NotImplemented - - cdef _pow_(self, other): - return NotImplemented - - cdef _iadd_scalar_(self, other): - return NotImplemented - - cdef _isub_scalar_(self, other): - return NotImplemented - - cdef _imul_scalar_(self, other): - return NotImplemented - - cdef _iadd_mpoly_(self, other): - return NotImplemented - - cdef _isub_mpoly_(self, other): - return NotImplemented - - cdef _imul_mpoly_(self, other): - return NotImplemented - - def __add__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - return self._add_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - return self._add_scalar_(other) - - def __radd__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - return self._add_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - return self._add_scalar_(other) - - def __sub__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - return self._sub_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - return self._sub_scalar_(other) - - def __rsub__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - return self._rsub_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - return self._rsub_scalar_(other) - - def __mul__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - return self._mul_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - return self._mul_scalar_(other) - - def __rmul__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - return self._mul_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - return self._mul_scalar_(other) - - def __pow__(self, other, modulus): - if modulus is not None: - raise NotImplementedError("cannot specify modulus outside of the context") - - if not typecheck(other, fmpz): - other = any_as_fmpz(other) - if other is NotImplemented: - return NotImplemented - - if fmpz_cmp_si((other).val, 0) < 0: - self = 1 / self - other = -other - - return self._pow_(other) - - def __divmod__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._division_check(other) - return self._divmod_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - self._division_check(other) - return self._divmod_mpoly_(other) - - def __rdivmod__(self, other): - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - other._division_check(self) - return self._rdivmod_mpoly_(other) - - def __truediv__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._division_check(other) - return self._truediv_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - self._division_check(other) - res = self._truediv_scalar_(other) - if res is not NotImplemented: - return res - - other = self.context()._scalar_as_mpoly(other) - return self._truediv_mpoly_(other) - - def __rtruediv__(self, other): - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - other._division_check(self) - return self._rtruediv_mpoly_(other) - - def __floordiv__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._division_check(other) - return self._floordiv_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - self._division_check(other) - return self._floordiv_mpoly_(other) - - def __rfloordiv__(self, other): - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - other._division_check(self) - return self._rfloordiv_mpoly_(other) - - def __mod__(self, other): - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._division_check(other) - return self._mod_mpoly_(other) - - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - self._division_check(other) - return self._mod_mpoly_(other) - - def __rmod__(self, other): - other = self.context()._any_as_scalar(other) - if other is NotImplemented: - return NotImplemented - - other = self.context()._scalar_as_mpoly(other) - other._division_check(self) - return self._rmod_mpoly_(other) - - def iadd(self, other): - """ - In-place addition, mutates self. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> f - 4*x0*x1 + 2*x0 + 3*x1 - >>> f.iadd(5) - >>> f - 4*x0*x1 + 2*x0 + 3*x1 + 5 - - """ - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._iadd_mpoly_(other) - return - - other_scalar = self.context()._any_as_scalar(other) - if other_scalar is NotImplemented: - raise NotImplementedError(f"cannot add {type(self)} and {type(other)}") - - self._iadd_scalar_(other_scalar) - - def isub(self, other): - """ - In-place subtraction, mutates self. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> f - 4*x0*x1 + 2*x0 + 3*x1 - >>> f.isub(5) - >>> f - 4*x0*x1 + 2*x0 + 3*x1 - 5 - - """ - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._isub_mpoly_(other) - return - - other_scalar = self.context()._any_as_scalar(other) - if other_scalar is NotImplemented: - raise NotImplementedError(f"cannot subtract {type(self)} and {type(other)}") - - self._isub_scalar_(other_scalar) - - def imul(self, other): - """ - In-place multiplication, mutates self. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> f - 4*x0*x1 + 2*x0 + 3*x1 - >>> f.imul(2) - >>> f - 8*x0*x1 + 4*x0 + 6*x1 - - """ - if typecheck(other, type(self)): - self.context().compatible_context_check(other.context()) - self._imul_mpoly_(other) - return - - other_scalar = self.context()._any_as_scalar(other) - if other_scalar is NotImplemented: - raise NotImplementedError(f"cannot multiply {type(self)} and {type(other)}") - - self._imul_scalar_(other_scalar) - - def __contains__(self, x): - """ - Returns True if ``self`` contains a term with exponent vector ``x`` and a non-zero coefficient. - - >>> from flint import fmpq_mpoly_ctx - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> (1, 1) in p - True - >>> (5, 1) in p - False - - """ - return bool(self[x]) - - def __iter__(self): - return iter(self.monoms()) - - def __pos__(self): - return self - - def terms(self): - """ - Return the exponent vectors and coefficient of each term. - - >>> from flint import fmpq_mpoly_ctx - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(0, 0): 1, (1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> list(f.terms()) - [((1, 1), 4), ((1, 0), 2), ((0, 1), 3), ((0, 0), 1)] - - """ - return zip(self.monoms(), self.coeffs()) - - def unused_gens(self): - """ - Report the unused generators from this polynomial. - - A generator is unused if it's maximum degree is 0. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 4)) - >>> ctx2 = fmpz_mpoly_ctx.get(('x1', 'x2')) - >>> f = sum(ctx.gens()[1:3]) - >>> f - x1 + x2 - >>> f.unused_gens() - ('x0', 'x3') - """ - names = self.context().names() - return tuple(names[i] for i, x in enumerate(self.degrees()) if x <= 0) - - def project_to_context(self, other_ctx, mapping: dict[str | int, str | int] = None): - """ - Project this polynomial to a different context. - - This is equivalent to composing this polynomial with the generators of another - context. By default the mapping between contexts is inferred based on the name - of the generators. Generators with names that are not found within the other - context are mapped to 0. The mapping can be explicitly provided. - - >>> from flint import fmpz_mpoly_ctx - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y', 'a', 'b')) - >>> ctx2 = fmpz_mpoly_ctx.get(('a', 'b')) - >>> x, y, a, b = ctx.gens() - >>> f = x + 2*y + 3*a + 4*b - >>> f.project_to_context(ctx2) - 3*a + 4*b - >>> f.project_to_context(ctx2, mapping={"x": "a", "b": 0}) - 5*a - """ - cdef: - slong *c_mapping - slong i - - ctx = self.context() - if not typecheck(other_ctx, type(ctx)): - raise ValueError( - f"provided context is not a {ctx.__class__.__name__}" - ) - elif ctx is other_ctx: - return self - - if mapping is None: - mapping = ctx.infer_generator_mapping(other_ctx) - else: - mapping = { - ctx.variable_to_index(k): other_ctx.variable_to_index(v) - for k, v in mapping.items() - } - - try: - c_mapping = libc.stdlib.malloc(ctx.nvars() * sizeof(slong *)) - if c_mapping is NULL: - raise MemoryError("malloc returned a null pointer") - - for i in range(ctx.nvars()): - c_mapping[i] = -1 - - for k, v in mapping.items(): - c_mapping[k] = v - - return self._compose_gens_(other_ctx, c_mapping) - finally: - libc.stdlib.free(c_mapping) - - cdef _compose_gens_(self, other_ctx, slong *mapping): - raise NotImplementedError("abstract method") - - -cdef class flint_series(flint_elem): - """ - Base class for power series. - """ - def __iter__(self): - cdef long i, n - n = self.length() - for i in range(n): - yield self[i] - - def coeffs(self): - return list(self) - - -cdef class flint_mat(flint_elem): - """ - Base class for matrices. - """ - - def repr(self): - # XXX - return "%s(%i, %i, [%s])" % (type(self).__name__, - self.nrows(), - self.ncols(), - ", ".join(map(str, self.entries()))) - - def str(self, *args, **kwargs): - tab = self.table() - if len(tab) == 0 or len(tab[0]) == 0: - return "[]" - tab = [[r.str(*args, **kwargs) for r in row] for row in tab] - widths = [] - for i in xrange(len(tab[0])): - w = max([len(row[i]) for row in tab]) - widths.append(w) - for i in xrange(len(tab)): - tab[i] = [s.rjust(widths[j]) for j, s in enumerate(tab[i])] - tab[i] = "[" + (", ".join(tab[i])) + "]" - return "\n".join(tab) - - def entries(self): - cdef long i, j, m, n - m = self.nrows() - n = self.ncols() - L = [None] * (m * n) - for i from 0 <= i < m: - for j from 0 <= j < n: - L[i*n + j] = self[i, j] - return L - - def __iter__(self): - cdef long i, j, m, n - m = self.nrows() - n = self.ncols() - for i from 0 <= i < m: - for j from 0 <= j < n: - yield self[i, j] - - def table(self): - cdef long i, m, n - m = self.nrows() - n = self.ncols() - L = self.entries() - return [L[i*n : (i+1)*n] for i in range(m)] - - # supports mpmath conversions - tolist = table diff --git a/src/flint/flint_base/flint_context.pxd b/src/flint/flint_base/flint_context.pxd deleted file mode 100644 index cc060acc..00000000 --- a/src/flint/flint_base/flint_context.pxd +++ /dev/null @@ -1,25 +0,0 @@ -from flint.flintlib.types.arf cimport ( - arf_rnd_t, -) - -cdef class FlintContext: - cdef public bint pretty - cdef public long _prec - cdef public long _dps - cdef arf_rnd_t rnd - cdef public bint unicode - cdef public long _cap - -cdef FlintContext thectx - -cdef inline long getprec(long prec=0): - if prec > 1: - return prec - else: - return thectx._prec - -cdef inline long getcap(long cap=-1): - if cap >= 0: - return cap - else: - return thectx._cap diff --git a/src/flint/flint_base/flint_context.pyx b/src/flint/flint_base/flint_context.pyx deleted file mode 100644 index 324510cb..00000000 --- a/src/flint/flint_base/flint_context.pyx +++ /dev/null @@ -1,203 +0,0 @@ -from flint.flintlib.types.arf cimport arf_rnd_t -from flint.flintlib.types.flint cimport ( - flint_cleanup, - flint_get_num_threads, - flint_set_num_threads -) -from flint.utils.conversion cimport prec_to_dps, dps_to_prec - -from functools import wraps - -cdef class FlintContext: - def __init__(self): - self.default() - - def default(self): - self.pretty = True - self.rnd = arf_rnd_t.ARF_RND_DOWN - self.prec = 53 - self.unicode = False - self.threads = 1 - self.cap = 10 - - @property - def prec(self): - return self._prec - - @prec.setter - def prec(self, prec): - cdef long cprec = prec - if cprec < 2: - raise ValueError("prec must be >= 2") - self._prec = cprec - self._dps = prec_to_dps(cprec) - - @property - def dps(self): - return self._dps - - @dps.setter - def dps(self, prec): - self.prec = dps_to_prec(prec) - - @property - def cap(self): - return self._cap - - @cap.setter - def cap(self, long cap): - if cap < 0: - raise ValueError("cap must be >= 0") - self._cap = cap - - @property - def threads(self): - return flint_get_num_threads() - - @threads.setter - def threads(self, long num): - assert num >= 1 and num <= 64 - flint_set_num_threads(num) - - def extraprec(self, n): - """ - Adds n bits of precision to the current flint context. - - >>> from flint import arb, ctx - >>> with ctx.extraprec(5): x = arb(2).sqrt().str() - >>> x - '[1.414213562373095 +/- 5.53e-17]' - - This function also works as a wrapper: - - >>> from flint import arb, ctx - >>> @ctx.extraprec(10) - ... def f(x): - ... return x.sqrt().str() - >>> f(arb(2)) - '[1.41421356237309505 +/- 1.46e-18]' - """ - return self.workprec(n + self.prec) - - def extradps(self, n): - """ - Adds n digits of precision to the current flint context. - - >>> from flint import arb, ctx - >>> with ctx.extradps(5): x = arb(2).sqrt().str() - >>> x - '[1.4142135623730950488 +/- 2.76e-21]' - - This function also works as a wrapper: - - >>> from flint import arb, ctx - >>> @ctx.extradps(10) - ... def f(x): - ... return x.sqrt().str() - >>> f(arb(2)) - '[1.414213562373095048801689 +/- 3.13e-25]' - """ - return self.workdps(n + self.dps) - - def workprec(self, n): - """ - Sets the working precision for the current flint context, - using a python context manager. - - >>> from flint import arb, ctx - >>> with ctx.workprec(5): x = arb(2).sqrt().str() - >>> x - '[1e+0 +/- 0.438]' - - This function also works as a wrapper: - - >>> from flint import arb, ctx - >>> @ctx.workprec(24) - ... def f(x): - ... return x.sqrt().str() - >>> f(arb(2)) - '[1.41421 +/- 3.66e-6]' - """ - return PrecisionManager(self, eprec=n) - - def workdps(self, n): - """ - Sets the working precision in digits for the current - flint context, using a python context manager. - - >>> from flint import arb, ctx - >>> with ctx.workdps(5): x = arb(2).sqrt().str() - >>> x - '[1.4142 +/- 1.51e-5]' - - This function also works as a wrapper: - - >>> from flint import arb, ctx - >>> @ctx.workdps(10) - ... def f(x): - ... return x.sqrt().str() - >>> f(arb(2)) - '[1.414213562 +/- 3.85e-10]' - """ - return PrecisionManager(self, edps=n) - - def __repr__(self): - return "pretty = %-8s # pretty-print repr() output\n" \ - "unicode = %-8s # use unicode characters in output\n" \ - "prec = %-8s # real/complex precision (in bits)\n" \ - "dps = %-8s # real/complex precision (in digits)\n" \ - "cap = %-8s # power series precision\n" \ - "threads = %-8s # max number of threads used internally" % \ - (self.pretty, self.unicode, self.prec, self.dps, self.cap, self.threads) - - def cleanup(self): - flint_cleanup() - - -cdef class PrecisionManager: - cdef FlintContext ctx - cdef int eprec - cdef int edps - cdef int _oldprec - - def __init__(self, ctx, eprec=-1, edps=-1): - if eprec != -1 and edps != -1: - raise ValueError("two different precisions requested") - - self.ctx = ctx - - self.eprec = eprec - self.edps = edps - - def __call__(self, func): - @wraps(func) - def wrapped(*args, **kwargs): - _oldprec = self.ctx.prec - - try: - if self.eprec != -1: - self.ctx.prec = self.eprec - - if self.edps != -1: - self.ctx.dps = self.edps - - return func(*args, **kwargs) - finally: - self.ctx.prec = _oldprec - - return wrapped - - def __enter__(self): - self._oldprec = self.ctx.prec - - if self.eprec != -1: - self.ctx.prec = self.eprec - - if self.edps != -1: - self.ctx.dps = self.edps - - def __exit__(self, type, value, traceback): - self.ctx.prec = self._oldprec - - -cdef FlintContext thectx = FlintContext() diff --git a/src/flint/flint_base/meson.build b/src/flint/flint_base/meson.build deleted file mode 100644 index 6057efd0..00000000 --- a/src/flint/flint_base/meson.build +++ /dev/null @@ -1,28 +0,0 @@ -pkgdir = 'flint/flint_base' - -pyfiles = [ - '__init__.py', - 'flint_base.pyi', -] - -exts = [ - 'flint_base', - 'flint_context', -] - -py.install_sources( - pyfiles, - pure: false, - subdir: pkgdir, -) - -foreach ext : exts - py.extension_module( - ext, - ext + '.pyx', - dependencies: pyflint_deps, - install: true, - subdir: pkgdir, - limited_api: limited_api_version, - ) -endforeach diff --git a/src/flint/flintlib/README.md b/src/flint/flintlib/README.md deleted file mode 100644 index 2c0308e1..00000000 --- a/src/flint/flintlib/README.md +++ /dev/null @@ -1,35 +0,0 @@ -Cython declarations for functions exported by libflint -====================================================== - -This directory contains Cython declarations for functions exported by libflint. -The declarations under the `types` directory are for the types defined in -libflint and are hand-written. The declarations under the `functions` directory -are for the functions defined in libflint and are generated by running: -```console -$ bin/all_rst_to_pxd.sh /path/to/flint/doc/source -``` -where `/path/to/flint/doc/source` is the path to the source directory of the -flint documentation. This command should always be run on the FLINT docs of the -version of FLINT that is used by default in python-flint's wheels which is the -version shown in the `bin/build_variables.sh` script. Typically this just means -the latest released version of FLINT. - -It is important not to edit any of the files in `functions` manually because a -subsequent run of `bin/all_rst_to_pxd.sh` will overwrite them. There are -several reasons why manual editing may be needed but usually it is because -either: - -1. The function is not documented in the FLINT docs. -2. The function is a macro and not a function. - -In either case, we need to manually write the declaration for the function but -it cannot be done in the `functions` directory. Instead, it should be added -somewhere in the `types` directory. - -Generally undocumented functions should be reported/fixed upstream in FLINT. - -It might be better to list macros (and undocumented functions) in the -`bin/rst_to_pxd.py` script so that it can add them to the generated files -automatically. Then we can keep them out of the hand-written code but also keep -track of them with a goal of eventually getting all of them added to the FLINT -docs. diff --git a/src/flint/flintlib/__init__.py b/src/flint/flintlib/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/flintlib/functions/__init__.pxd b/src/flint/flintlib/functions/__init__.pxd deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/flintlib/functions/__init__.py b/src/flint/flintlib/functions/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/flintlib/functions/acb.pxd b/src/flint/flintlib/functions/acb.pxd deleted file mode 100644 index e33491a4..00000000 --- a/src/flint/flintlib/functions/acb.pxd +++ /dev/null @@ -1,265 +0,0 @@ -from flint.flintlib.types.acb cimport acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.arb cimport arb_ptr, arb_srcptr, arb_t, mag_srcptr, mag_t -from flint.flintlib.types.arf cimport arf_srcptr, arf_t -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t - -# unknown type FILE - -# .. macro:: acb_realref(x) -# .. macro:: acb_imagref(x) - -cdef extern from "flint/acb.h": - void acb_init(acb_t x) - void acb_clear(acb_t x) - acb_ptr _acb_vec_init(slong n) - void _acb_vec_clear(acb_ptr v, slong n) - slong acb_allocated_bytes(const acb_t x) - slong _acb_vec_allocated_bytes(acb_srcptr vec, slong len) - double _acb_vec_estimate_allocated_bytes(slong len, slong prec) - void acb_zero(acb_t z) - void acb_one(acb_t z) - void acb_onei(acb_t z) - void acb_set(acb_t z, const acb_t x) - void acb_set_ui(acb_t z, ulong x) - void acb_set_si(acb_t z, slong x) - void acb_set_d(acb_t z, double x) - void acb_set_fmpz(acb_t z, const fmpz_t x) - void acb_set_arb(acb_t z, const arb_t c) - void acb_set_si_si(acb_t z, slong x, slong y) - void acb_set_d_d(acb_t z, double x, double y) - void acb_set_fmpz_fmpz(acb_t z, const fmpz_t x, const fmpz_t y) - void acb_set_arb_arb(acb_t z, const arb_t x, const arb_t y) - void acb_set_fmpq(acb_t z, const fmpq_t x, slong prec) - void acb_set_round(acb_t z, const acb_t x, slong prec) - void acb_set_round_fmpz(acb_t z, const fmpz_t x, slong prec) - void acb_set_round_arb(acb_t z, const arb_t x, slong prec) - void acb_swap(acb_t z, acb_t x) - void acb_add_error_arf(acb_t x, const arf_t err) - void acb_add_error_mag(acb_t x, const mag_t err) - void acb_add_error_arb(acb_t x, const arb_t err) - void acb_get_mid(acb_t m, const acb_t x) - void acb_print(const acb_t x) - # void acb_fprint(FILE * file, const acb_t x) - void acb_printd(const acb_t x, slong digits) - # void acb_fprintd(FILE * file, const acb_t x, slong digits) - void acb_printn(const acb_t x, slong digits, ulong flags) - # void acb_fprintn(FILE * file, const acb_t x, slong digits, ulong flags) - void acb_randtest(acb_t z, flint_rand_t state, slong prec, slong mag_bits) - void acb_randtest_special(acb_t z, flint_rand_t state, slong prec, slong mag_bits) - void acb_randtest_precise(acb_t z, flint_rand_t state, slong prec, slong mag_bits) - void acb_randtest_param(acb_t z, flint_rand_t state, slong prec, slong mag_bits) - void acb_urandom(acb_t z, flint_rand_t state, slong prec) - int acb_is_zero(const acb_t z) - int acb_is_one(const acb_t z) - int acb_is_finite(const acb_t z) - int acb_is_exact(const acb_t z) - int acb_is_int(const acb_t z) - int acb_is_int_2exp_si(const acb_t x, slong e) - int acb_equal(const acb_t x, const acb_t y) - int acb_equal_si(const acb_t x, slong y) - int acb_eq(const acb_t x, const acb_t y) - int acb_ne(const acb_t x, const acb_t y) - int acb_overlaps(const acb_t x, const acb_t y) - void acb_union(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_get_abs_ubound_arf(arf_t u, const acb_t z, slong prec) - void acb_get_abs_lbound_arf(arf_t u, const acb_t z, slong prec) - void acb_get_rad_ubound_arf(arf_t u, const acb_t z, slong prec) - void acb_get_mag(mag_t u, const acb_t x) - void acb_get_mag_lower(mag_t u, const acb_t x) - int acb_contains_fmpq(const acb_t x, const fmpq_t y) - int acb_contains_fmpz(const acb_t x, const fmpz_t y) - int acb_contains(const acb_t x, const acb_t y) - int acb_contains_zero(const acb_t x) - int acb_contains_int(const acb_t x) - int acb_contains_interior(const acb_t x, const acb_t y) - slong acb_rel_error_bits(const acb_t x) - slong acb_rel_accuracy_bits(const acb_t x) - slong acb_rel_one_accuracy_bits(const acb_t x) - slong acb_bits(const acb_t x) - void acb_indeterminate(acb_t x) - void acb_trim(acb_t y, const acb_t x) - int acb_is_real(const acb_t x) - int acb_get_unique_fmpz(fmpz_t z, const acb_t x) - void acb_get_real(arb_t re, const acb_t z) - void acb_get_imag(arb_t im, const acb_t z) - void acb_arg(arb_t r, const acb_t z, slong prec) - void acb_abs(arb_t r, const acb_t z, slong prec) - void acb_sgn(acb_t r, const acb_t z, slong prec) - void acb_csgn(arb_t r, const acb_t z) - void acb_neg(acb_t z, const acb_t x) - void acb_neg_round(acb_t z, const acb_t x, slong prec) - void acb_conj(acb_t z, const acb_t x) - void acb_add_ui(acb_t z, const acb_t x, ulong y, slong prec) - void acb_add_si(acb_t z, const acb_t x, slong y, slong prec) - void acb_add_fmpz(acb_t z, const acb_t x, const fmpz_t y, slong prec) - void acb_add_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_add(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_sub_ui(acb_t z, const acb_t x, ulong y, slong prec) - void acb_sub_si(acb_t z, const acb_t x, slong y, slong prec) - void acb_sub_fmpz(acb_t z, const acb_t x, const fmpz_t y, slong prec) - void acb_sub_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_sub(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_mul_onei(acb_t z, const acb_t x) - void acb_div_onei(acb_t z, const acb_t x) - void acb_mul_i_pow_si(acb_t z, const acb_t x, slong k) - void acb_mul_ui(acb_t z, const acb_t x, ulong y, slong prec) - void acb_mul_si(acb_t z, const acb_t x, slong y, slong prec) - void acb_mul_fmpz(acb_t z, const acb_t x, const fmpz_t y, slong prec) - void acb_mul_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_mul(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_mul_2exp_si(acb_t z, const acb_t x, slong e) - void acb_mul_2exp_fmpz(acb_t z, const acb_t x, const fmpz_t e) - void acb_sqr(acb_t z, const acb_t x, slong prec) - void acb_cube(acb_t z, const acb_t x, slong prec) - void acb_addmul(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_addmul_ui(acb_t z, const acb_t x, ulong y, slong prec) - void acb_addmul_si(acb_t z, const acb_t x, slong y, slong prec) - void acb_addmul_fmpz(acb_t z, const acb_t x, const fmpz_t y, slong prec) - void acb_addmul_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_submul(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_submul_ui(acb_t z, const acb_t x, ulong y, slong prec) - void acb_submul_si(acb_t z, const acb_t x, slong y, slong prec) - void acb_submul_fmpz(acb_t z, const acb_t x, const fmpz_t y, slong prec) - void acb_submul_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_inv(acb_t z, const acb_t x, slong prec) - void acb_div_ui(acb_t z, const acb_t x, ulong y, slong prec) - void acb_div_si(acb_t z, const acb_t x, slong y, slong prec) - void acb_div_fmpz(acb_t z, const acb_t x, const fmpz_t y, slong prec) - void acb_div_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_div(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_dot_precise(acb_t res, const acb_t s, int subtract, acb_srcptr x, slong xstep, acb_srcptr y, slong ystep, slong len, slong prec) - void acb_dot_simple(acb_t res, const acb_t s, int subtract, acb_srcptr x, slong xstep, acb_srcptr y, slong ystep, slong len, slong prec) - void acb_dot(acb_t res, const acb_t s, int subtract, acb_srcptr x, slong xstep, acb_srcptr y, slong ystep, slong len, slong prec) - void acb_approx_dot(acb_t res, const acb_t s, int subtract, acb_srcptr x, slong xstep, acb_srcptr y, slong ystep, slong len, slong prec) - void acb_dot_ui(acb_t res, const acb_t initial, int subtract, acb_srcptr x, slong xstep, const ulong * y, slong ystep, slong len, slong prec) - void acb_dot_si(acb_t res, const acb_t initial, int subtract, acb_srcptr x, slong xstep, const slong * y, slong ystep, slong len, slong prec) - void acb_dot_uiui(acb_t res, const acb_t initial, int subtract, acb_srcptr x, slong xstep, const ulong * y, slong ystep, slong len, slong prec) - void acb_dot_siui(acb_t res, const acb_t initial, int subtract, acb_srcptr x, slong xstep, const ulong * y, slong ystep, slong len, slong prec) - void acb_dot_fmpz(acb_t res, const acb_t initial, int subtract, acb_srcptr x, slong xstep, const fmpz_struct * y, slong ystep, slong len, slong prec) - void acb_const_pi(acb_t y, slong prec) - void acb_sqrt(acb_t r, const acb_t z, slong prec) - void acb_sqrt_analytic(acb_t r, const acb_t z, int analytic, slong prec) - void acb_rsqrt(acb_t r, const acb_t z, slong prec) - void acb_rsqrt_analytic(acb_t r, const acb_t z, int analytic, slong prec) - void acb_sqrts(acb_t y1, acb_t y2, const acb_t x, slong prec) - void acb_quadratic_roots_fmpz(acb_t r1, acb_t r2, const fmpz_t a, const fmpz_t b, const fmpz_t c, slong prec) - void acb_root_ui(acb_t r, const acb_t z, ulong k, slong prec) - void acb_pow_fmpz(acb_t y, const acb_t b, const fmpz_t e, slong prec) - void acb_pow_ui(acb_t y, const acb_t b, ulong e, slong prec) - void acb_pow_si(acb_t y, const acb_t b, slong e, slong prec) - void acb_pow_arb(acb_t z, const acb_t x, const arb_t y, slong prec) - void acb_pow(acb_t z, const acb_t x, const acb_t y, slong prec) - void acb_pow_analytic(acb_t r, const acb_t x, const acb_t y, int analytic, slong prec) - void acb_unit_root(acb_t res, ulong order, slong prec) - void acb_exp(acb_t y, const acb_t z, slong prec) - void acb_exp_pi_i(acb_t y, const acb_t z, slong prec) - void acb_exp_invexp(acb_t s, acb_t t, const acb_t z, slong prec) - void acb_expm1(acb_t res, const acb_t z, slong prec) - void acb_log(acb_t y, const acb_t z, slong prec) - void acb_log_analytic(acb_t r, const acb_t z, int analytic, slong prec) - void acb_log1p(acb_t z, const acb_t x, slong prec) - void acb_sin(acb_t s, const acb_t z, slong prec) - void acb_cos(acb_t c, const acb_t z, slong prec) - void acb_sin_cos(acb_t s, acb_t c, const acb_t z, slong prec) - void acb_tan(acb_t s, const acb_t z, slong prec) - void acb_cot(acb_t s, const acb_t z, slong prec) - void acb_sin_pi(acb_t s, const acb_t z, slong prec) - void acb_cos_pi(acb_t s, const acb_t z, slong prec) - void acb_sin_cos_pi(acb_t s, acb_t c, const acb_t z, slong prec) - void acb_tan_pi(acb_t s, const acb_t z, slong prec) - void acb_cot_pi(acb_t s, const acb_t z, slong prec) - void acb_sec(acb_t res, const acb_t z, slong prec) - void acb_csc(acb_t res, const acb_t z, slong prec) - void acb_csc_pi(acb_t res, const acb_t z, slong prec) - void acb_sinc(acb_t s, const acb_t z, slong prec) - void acb_sinc_pi(acb_t s, const acb_t z, slong prec) - void acb_asin(acb_t res, const acb_t z, slong prec) - void acb_acos(acb_t res, const acb_t z, slong prec) - void acb_atan(acb_t res, const acb_t z, slong prec) - void acb_sinh(acb_t s, const acb_t z, slong prec) - void acb_cosh(acb_t c, const acb_t z, slong prec) - void acb_sinh_cosh(acb_t s, acb_t c, const acb_t z, slong prec) - void acb_tanh(acb_t s, const acb_t z, slong prec) - void acb_coth(acb_t s, const acb_t z, slong prec) - void acb_sech(acb_t res, const acb_t z, slong prec) - void acb_csch(acb_t res, const acb_t z, slong prec) - void acb_asinh(acb_t res, const acb_t z, slong prec) - void acb_acosh(acb_t res, const acb_t z, slong prec) - void acb_atanh(acb_t res, const acb_t z, slong prec) - void acb_lambertw_asymp(acb_t res, const acb_t z, const fmpz_t k, slong L, slong M, slong prec) - int acb_lambertw_check_branch(const acb_t w, const fmpz_t k, slong prec) - void acb_lambertw_bound_deriv(mag_t res, const acb_t z, const acb_t ez1, const fmpz_t k) - void acb_lambertw(acb_t res, const acb_t z, const fmpz_t k, int flags, slong prec) - void acb_rising_ui(acb_t z, const acb_t x, ulong n, slong prec) - void acb_rising(acb_t z, const acb_t x, const acb_t n, slong prec) - void acb_rising2_ui(acb_t u, acb_t v, const acb_t x, ulong n, slong prec) - void acb_rising_ui_get_mag(mag_t bound, const acb_t x, ulong n) - void acb_gamma(acb_t y, const acb_t x, slong prec) - void acb_rgamma(acb_t y, const acb_t x, slong prec) - void acb_lgamma(acb_t y, const acb_t x, slong prec) - void acb_digamma(acb_t y, const acb_t x, slong prec) - void acb_log_sin_pi(acb_t res, const acb_t z, slong prec) - void acb_polygamma(acb_t res, const acb_t s, const acb_t z, slong prec) - void acb_barnes_g(acb_t res, const acb_t z, slong prec) - void acb_log_barnes_g(acb_t res, const acb_t z, slong prec) - void acb_zeta(acb_t z, const acb_t s, slong prec) - void acb_hurwitz_zeta(acb_t z, const acb_t s, const acb_t a, slong prec) - void acb_bernoulli_poly_ui(acb_t res, ulong n, const acb_t x, slong prec) - void acb_polylog(acb_t w, const acb_t s, const acb_t z, slong prec) - void acb_polylog_si(acb_t w, slong s, const acb_t z, slong prec) - void acb_agm1(acb_t m, const acb_t z, slong prec) - void acb_agm1_cpx(acb_ptr m, const acb_t z, slong len, slong prec) - void acb_agm(acb_t m, const acb_t x, const acb_t y, slong prec) - void acb_chebyshev_t_ui(acb_t a, ulong n, const acb_t x, slong prec) - void acb_chebyshev_u_ui(acb_t a, ulong n, const acb_t x, slong prec) - void acb_chebyshev_t2_ui(acb_t a, acb_t b, ulong n, const acb_t x, slong prec) - void acb_chebyshev_u2_ui(acb_t a, acb_t b, ulong n, const acb_t x, slong prec) - void acb_real_abs(acb_t res, const acb_t z, int analytic, slong prec) - void acb_real_sgn(acb_t res, const acb_t z, int analytic, slong prec) - void acb_real_heaviside(acb_t res, const acb_t z, int analytic, slong prec) - void acb_real_floor(acb_t res, const acb_t z, int analytic, slong prec) - void acb_real_ceil(acb_t res, const acb_t z, int analytic, slong prec) - void acb_real_max(acb_t res, const acb_t x, const acb_t y, int analytic, slong prec) - void acb_real_min(acb_t res, const acb_t x, const acb_t y, int analytic, slong prec) - void acb_real_sqrtpos(acb_t res, const acb_t z, int analytic, slong prec) - void _acb_vec_zero(acb_ptr A, slong n) - int _acb_vec_is_zero(acb_srcptr vec, slong len) - int _acb_vec_is_real(acb_srcptr v, slong len) - int _acb_vec_is_finite(acb_srcptr vec, slong len) - int _acb_vec_equal(acb_srcptr vec1, acb_srcptr vec2, slong len) - int _acb_vec_overlaps(acb_srcptr vec1, acb_srcptr vec2, slong len) - int _acb_vec_contains(acb_srcptr vec1, acb_srcptr vec2, slong len) - void _acb_vec_set(acb_ptr res, acb_srcptr vec, slong len) - void _acb_vec_set_round(acb_ptr res, acb_srcptr vec, slong len, slong prec) - void _acb_vec_swap(acb_ptr vec1, acb_ptr vec2, slong len) - void _acb_vec_get_real(arb_ptr re, acb_srcptr vec, slong len) - void _acb_vec_get_imag(arb_ptr im, acb_srcptr vec, slong len) - void _acb_vec_set_real_imag(acb_ptr vec, arb_srcptr re, arb_srcptr im, slong len) - void _acb_vec_neg(acb_ptr res, acb_srcptr vec, slong len) - void _acb_vec_add(acb_ptr res, acb_srcptr vec1, acb_srcptr vec2, slong len, slong prec) - void _acb_vec_sub(acb_ptr res, acb_srcptr vec1, acb_srcptr vec2, slong len, slong prec) - void _acb_vec_scalar_submul(acb_ptr res, acb_srcptr vec, slong len, const acb_t c, slong prec) - void _acb_vec_scalar_addmul(acb_ptr res, acb_srcptr vec, slong len, const acb_t c, slong prec) - void _acb_vec_scalar_mul(acb_ptr res, acb_srcptr vec, slong len, const acb_t c, slong prec) - void _acb_vec_scalar_mul_ui(acb_ptr res, acb_srcptr vec, slong len, ulong c, slong prec) - void _acb_vec_scalar_mul_2exp_si(acb_ptr res, acb_srcptr vec, slong len, slong c) - void _acb_vec_scalar_mul_onei(acb_ptr res, acb_srcptr vec, slong len) - void _acb_vec_scalar_div_ui(acb_ptr res, acb_srcptr vec, slong len, ulong c, slong prec) - void _acb_vec_scalar_div(acb_ptr res, acb_srcptr vec, slong len, const acb_t c, slong prec) - void _acb_vec_scalar_mul_arb(acb_ptr res, acb_srcptr vec, slong len, const arb_t c, slong prec) - void _acb_vec_scalar_div_arb(acb_ptr res, acb_srcptr vec, slong len, const arb_t c, slong prec) - void _acb_vec_scalar_mul_fmpz(acb_ptr res, acb_srcptr vec, slong len, const fmpz_t c, slong prec) - void _acb_vec_scalar_div_fmpz(acb_ptr res, acb_srcptr vec, slong len, const fmpz_t c, slong prec) - void _acb_vec_sqr(acb_ptr res, acb_srcptr vec, slong len, slong prec) - slong _acb_vec_bits(acb_srcptr vec, slong len) - void _acb_vec_set_powers(acb_ptr xs, const acb_t x, slong len, slong prec) - void _acb_vec_unit_roots(acb_ptr z, slong order, slong len, slong prec) - void _acb_vec_add_error_arf_vec(acb_ptr res, arf_srcptr err, slong len) - void _acb_vec_add_error_mag_vec(acb_ptr res, mag_srcptr err, slong len) - void _acb_vec_indeterminate(acb_ptr vec, slong len) - void _acb_vec_trim(acb_ptr res, acb_srcptr vec, slong len) - int _acb_vec_get_unique_fmpz_vec(fmpz_struct * res, acb_srcptr vec, slong len) - void _acb_vec_sort_pretty(acb_ptr vec, slong len) - void _acb_vec_printd(acb_srcptr vec, slong len, slong digits) - void _acb_vec_printn(acb_srcptr vec, slong len, slong digits, ulong flags) diff --git a/src/flint/flintlib/functions/acb_calc.pxd b/src/flint/flintlib/functions/acb_calc.pxd deleted file mode 100644 index 2b783f6c..00000000 --- a/src/flint/flintlib/functions/acb_calc.pxd +++ /dev/null @@ -1,14 +0,0 @@ -from flint.flintlib.types.acb cimport acb_t -from flint.flintlib.types.acb_calc cimport acb_calc_func_t, acb_calc_integrate_opt_t -from flint.flintlib.types.arb cimport arb_t, mag_t -from flint.flintlib.types.arf cimport arf_t -from flint.flintlib.types.flint cimport slong - - - -cdef extern from "flint/acb_calc.h": - int acb_calc_integrate(acb_t res, acb_calc_func_t func, void * param, const acb_t a, const acb_t b, slong rel_goal, const mag_t abs_tol, const acb_calc_integrate_opt_t options, slong prec) - void acb_calc_integrate_opt_init(acb_calc_integrate_opt_t options) - int acb_calc_integrate_gl_auto_deg(acb_t res, slong * num_eval, acb_calc_func_t func, void * param, const acb_t a, const acb_t b, const mag_t tol, slong deg_limit, int flags, slong prec) - void acb_calc_cauchy_bound(arb_t bound, acb_calc_func_t func, void * param, const acb_t x, const arb_t radius, slong maxdepth, slong prec) - int acb_calc_integrate_taylor(acb_t res, acb_calc_func_t func, void * param, const acb_t a, const acb_t b, const arf_t inner_radius, const arf_t outer_radius, slong accuracy_goal, slong prec) diff --git a/src/flint/flintlib/functions/acb_dft.pxd b/src/flint/flintlib/functions/acb_dft.pxd deleted file mode 100644 index 9a6e7bf1..00000000 --- a/src/flint/flintlib/functions/acb_dft.pxd +++ /dev/null @@ -1,47 +0,0 @@ -from flint.flintlib.types.acb cimport acb_ptr, acb_srcptr -from flint.flintlib.types.flint cimport slong - -# unknown type acb_dft_bluestein_t -# unknown type acb_dft_crt_t -# unknown type acb_dft_cyc_t -# unknown type acb_dft_naive_t -# unknown type acb_dft_pre_t -# unknown type acb_dft_prod_t -# unknown type acb_dft_rad2_t - - -cdef extern from "flint/acb_dft.h": - void acb_dft(acb_ptr w, acb_srcptr v, slong n, slong prec) - void acb_dft_inverse(acb_ptr w, acb_srcptr v, slong n, slong prec) - # void acb_dft_precomp_init(acb_dft_pre_t pre, slong len, slong prec) - # void acb_dft_precomp_clear(acb_dft_pre_t pre) - # void acb_dft_precomp(acb_ptr w, acb_srcptr v, const acb_dft_pre_t pre, slong prec) - # void acb_dft_inverse_precomp(acb_ptr w, acb_srcptr v, const acb_dft_pre_t pre, slong prec) - void acb_dirichlet_dft_prod(acb_ptr w, acb_srcptr v, slong * cyc, slong num, slong prec) - # void acb_dft_prod_init(acb_dft_prod_t t, slong * cyc, slong num, slong prec) - # void acb_dft_prod_clear(acb_dft_prod_t t) - # void acb_dirichlet_dft_prod_precomp(acb_ptr w, acb_srcptr v, const acb_dft_prod_t prod, slong prec) - void acb_dft_convol_naive(acb_ptr w, acb_srcptr f, acb_srcptr g, slong len, slong prec) - void acb_dft_convol_rad2(acb_ptr w, acb_srcptr f, acb_srcptr g, slong len, slong prec) - void acb_dft_convol(acb_ptr w, acb_srcptr f, acb_srcptr g, slong len, slong prec) - void acb_dft_naive(acb_ptr w, acb_srcptr v, slong n, slong prec) - # void acb_dft_naive_init(acb_dft_naive_t t, slong len, slong prec) - # void acb_dft_naive_clear(acb_dft_naive_t t) - # void acb_dft_naive_precomp(acb_ptr w, acb_srcptr v, const acb_dft_naive_t t, slong prec) - void acb_dft_crt(acb_ptr w, acb_srcptr v, slong n, slong prec) - # void acb_dft_crt_init(acb_dft_crt_t t, slong len, slong prec) - # void acb_dft_crt_clear(acb_dft_crt_t t) - # void acb_dft_crt_precomp(acb_ptr w, acb_srcptr v, const acb_dft_crt_t t, slong prec) - void acb_dft_cyc(acb_ptr w, acb_srcptr v, slong n, slong prec) - # void acb_dft_cyc_init(acb_dft_cyc_t t, slong len, slong prec) - # void acb_dft_cyc_clear(acb_dft_cyc_t t) - # void acb_dft_cyc_precomp(acb_ptr w, acb_srcptr v, const acb_dft_cyc_t t, slong prec) - void acb_dft_rad2(acb_ptr w, acb_srcptr v, int e, slong prec) - void acb_dft_inverse_rad2(acb_ptr w, acb_srcptr v, int e, slong prec) - # void acb_dft_rad2_init(acb_dft_rad2_t t, int e, slong prec) - # void acb_dft_rad2_clear(acb_dft_rad2_t t) - # void acb_dft_rad2_precomp(acb_ptr w, acb_srcptr v, const acb_dft_rad2_t t, slong prec) - void acb_dft_bluestein(acb_ptr w, acb_srcptr v, slong n, slong prec) - # void acb_dft_bluestein_init(acb_dft_bluestein_t t, slong len, slong prec) - # void acb_dft_bluestein_clear(acb_dft_bluestein_t t) - # void acb_dft_bluestein_precomp(acb_ptr w, acb_srcptr v, const acb_dft_bluestein_t t, slong prec) diff --git a/src/flint/flintlib/functions/acb_dirichlet.pxd b/src/flint/flintlib/functions/acb_dirichlet.pxd deleted file mode 100644 index 9cf7e840..00000000 --- a/src/flint/flintlib/functions/acb_dirichlet.pxd +++ /dev/null @@ -1,106 +0,0 @@ -from flint.flintlib.types.acb cimport acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.acb_dirichlet cimport acb_dirichlet_hurwitz_precomp_t, acb_dirichlet_roots_t -from flint.flintlib.types.arb cimport arb_ptr, arb_srcptr, arb_t, mag_t -from flint.flintlib.types.arf cimport arf_t -from flint.flintlib.types.dirichlet cimport dirichlet_char_t, dirichlet_group_t -from flint.flintlib.types.flint cimport fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t - - - -cdef extern from "flint/acb_dirichlet.h": - void acb_dirichlet_roots_init(acb_dirichlet_roots_t roots, ulong n, slong num, slong prec) - void acb_dirichlet_roots_clear(acb_dirichlet_roots_t roots) - void acb_dirichlet_root(acb_t res, const acb_dirichlet_roots_t roots, ulong k, slong prec) - void acb_dirichlet_powsum_term(acb_ptr res, arb_t log_prev, ulong * prev, const acb_t s, ulong k, int integer, int critical_line, slong len, slong prec) - void acb_dirichlet_powsum_sieved(acb_ptr res, const acb_t s, ulong n, slong len, slong prec) - void acb_dirichlet_powsum_smooth(acb_ptr res, const acb_t s, ulong n, slong len, slong prec) - void acb_dirichlet_zeta(acb_t res, const acb_t s, slong prec) - void acb_dirichlet_zeta_jet(acb_t res, const acb_t s, int deflate, slong len, slong prec) - void acb_dirichlet_zeta_bound(mag_t res, const acb_t s) - void acb_dirichlet_zeta_deriv_bound(mag_t der1, mag_t der2, const acb_t s) - void acb_dirichlet_eta(acb_t res, const acb_t s, slong prec) - void acb_dirichlet_xi(acb_t res, const acb_t s, slong prec) - void acb_dirichlet_zeta_rs_f_coeffs(acb_ptr f, const arb_t p, slong n, slong prec) - void acb_dirichlet_zeta_rs_d_coeffs(arb_ptr d, const arb_t sigma, slong k, slong prec) - void acb_dirichlet_zeta_rs_bound(mag_t err, const acb_t s, slong K) - void acb_dirichlet_zeta_rs_r(acb_t res, const acb_t s, slong K, slong prec) - void acb_dirichlet_zeta_rs(acb_t res, const acb_t s, slong K, slong prec) - void acb_dirichlet_zeta_jet_rs(acb_ptr res, const acb_t s, slong len, slong prec) - void acb_dirichlet_hurwitz(acb_t res, const acb_t s, const acb_t a, slong prec) - void acb_dirichlet_hurwitz_precomp_init(acb_dirichlet_hurwitz_precomp_t pre, const acb_t s, int deflate, slong A, slong K, slong N, slong prec) - void acb_dirichlet_hurwitz_precomp_init_num(acb_dirichlet_hurwitz_precomp_t pre, const acb_t s, int deflate, double num_eval, slong prec) - void acb_dirichlet_hurwitz_precomp_clear(acb_dirichlet_hurwitz_precomp_t pre) - void acb_dirichlet_hurwitz_precomp_choose_param(ulong * A, ulong * K, ulong * N, const acb_t s, double num_eval, slong prec) - void acb_dirichlet_hurwitz_precomp_bound(mag_t res, const acb_t s, slong A, slong K, slong N) - void acb_dirichlet_hurwitz_precomp_eval(acb_t res, const acb_dirichlet_hurwitz_precomp_t pre, ulong p, ulong q, slong prec) - void acb_dirichlet_lerch_phi_integral(acb_t res, const acb_t z, const acb_t s, const acb_t a, slong prec) - void acb_dirichlet_lerch_phi_direct(acb_t res, const acb_t z, const acb_t s, const acb_t a, slong prec) - void acb_dirichlet_lerch_phi(acb_t res, const acb_t z, const acb_t s, const acb_t a, slong prec) - void acb_dirichlet_stieltjes(acb_t res, const fmpz_t n, const acb_t a, slong prec) - void acb_dirichlet_chi(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, ulong n, slong prec) - void acb_dirichlet_chi_vec(acb_ptr v, const dirichlet_group_t G, const dirichlet_char_t chi, slong nv, slong prec) - void acb_dirichlet_pairing(acb_t res, const dirichlet_group_t G, ulong m, ulong n, slong prec) - void acb_dirichlet_pairing_char(acb_t res, const dirichlet_group_t G, const dirichlet_char_t a, const dirichlet_char_t b, slong prec) - void acb_dirichlet_gauss_sum_naive(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_gauss_sum_factor(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_gauss_sum_order2(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_gauss_sum_theta(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_gauss_sum(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_jacobi_sum_naive(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec) - void acb_dirichlet_jacobi_sum_factor(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec) - void acb_dirichlet_jacobi_sum_gauss(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec) - void acb_dirichlet_jacobi_sum(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2, slong prec) - void acb_dirichlet_jacobi_sum_ui(acb_t res, const dirichlet_group_t G, ulong a, ulong b, slong prec) - void acb_dirichlet_chi_theta_arb(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, const arb_t t, slong prec) - void acb_dirichlet_ui_theta_arb(acb_t res, const dirichlet_group_t G, ulong a, const arb_t t, slong prec) - ulong acb_dirichlet_theta_length(ulong q, const arb_t t, slong prec) - void acb_dirichlet_qseries_arb_powers_naive(acb_t res, const arb_t x, int p, const ulong * a, const acb_dirichlet_roots_t z, slong len, slong prec) - void acb_dirichlet_qseries_arb_powers_smallorder(acb_t res, const arb_t x, int p, const ulong * a, const acb_dirichlet_roots_t z, slong len, slong prec) - void acb_dirichlet_dft_conrey(acb_ptr w, acb_srcptr v, const dirichlet_group_t G, slong prec) - void acb_dirichlet_dft(acb_ptr w, acb_srcptr v, const dirichlet_group_t G, slong prec) - void acb_dirichlet_root_number_theta(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_root_number(acb_t res, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_l_hurwitz(acb_t res, const acb_t s, const acb_dirichlet_hurwitz_precomp_t precomp, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_l_euler_product(acb_t res, const acb_t s, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void _acb_dirichlet_euler_product_real_ui(arb_t res, ulong s, const signed char * chi, int mod, int reciprocal, slong prec) - void acb_dirichlet_l(acb_t res, const acb_t s, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_l_fmpq(acb_t res, const fmpq_t s, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_l_fmpq_afe(acb_t res, const fmpq_t s, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - void acb_dirichlet_l_vec_hurwitz(acb_ptr res, const acb_t s, const acb_dirichlet_hurwitz_precomp_t precomp, const dirichlet_group_t G, slong prec) - void acb_dirichlet_l_jet(acb_ptr res, const acb_t s, const dirichlet_group_t G, const dirichlet_char_t chi, int deflate, slong len, slong prec) - void _acb_dirichlet_l_series(acb_ptr res, acb_srcptr s, slong slen, const dirichlet_group_t G, const dirichlet_char_t chi, int deflate, slong len, slong prec) - void acb_dirichlet_l_series(acb_poly_t res, const acb_poly_t s, const dirichlet_group_t G, const dirichlet_char_t chi, int deflate, slong len, slong prec) - void acb_dirichlet_hardy_theta(acb_ptr res, const acb_t t, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, slong prec) - void acb_dirichlet_hardy_z(acb_ptr res, const acb_t t, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, slong prec) - void _acb_dirichlet_hardy_theta_series(acb_ptr res, acb_srcptr t, slong tlen, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, slong prec) - void acb_dirichlet_hardy_theta_series(acb_poly_t res, const acb_poly_t t, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, slong prec) - void _acb_dirichlet_hardy_z_series(acb_ptr res, acb_srcptr t, slong tlen, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, slong prec) - void acb_dirichlet_hardy_z_series(acb_poly_t res, const acb_poly_t t, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, slong prec) - void acb_dirichlet_gram_point(arb_t res, const fmpz_t n, const dirichlet_group_t G, const dirichlet_char_t chi, slong prec) - ulong acb_dirichlet_turing_method_bound(const fmpz_t p) - int _acb_dirichlet_definite_hardy_z(arb_t res, const arf_t t, slong * pprec) - void _acb_dirichlet_isolate_gram_hardy_z_zero(arf_t a, arf_t b, const fmpz_t n) - void _acb_dirichlet_isolate_rosser_hardy_z_zero(arf_t a, arf_t b, const fmpz_t n) - void _acb_dirichlet_isolate_turing_hardy_z_zero(arf_t a, arf_t b, const fmpz_t n) - void acb_dirichlet_isolate_hardy_z_zero(arf_t a, arf_t b, const fmpz_t n) - void _acb_dirichlet_refine_hardy_z_zero(arb_t res, const arf_t a, const arf_t b, slong prec) - void acb_dirichlet_hardy_z_zero(arb_t res, const fmpz_t n, slong prec) - void acb_dirichlet_hardy_z_zeros(arb_ptr res, const fmpz_t n, slong len, slong prec) - void acb_dirichlet_zeta_zero(acb_t res, const fmpz_t n, slong prec) - void acb_dirichlet_zeta_zeros(acb_ptr res, const fmpz_t n, slong len, slong prec) - void _acb_dirichlet_exact_zeta_nzeros(fmpz_t res, const arf_t t) - void acb_dirichlet_zeta_nzeros(arb_t res, const arb_t t, slong prec) - void acb_dirichlet_backlund_s(arb_t res, const arb_t t, slong prec) - void acb_dirichlet_backlund_s_bound(mag_t res, const arb_t t) - void acb_dirichlet_zeta_nzeros_gram(fmpz_t res, const fmpz_t n) - slong acb_dirichlet_backlund_s_gram(const fmpz_t n) - void acb_dirichlet_platt_scaled_lambda(arb_t res, const arb_t t, slong prec) - void acb_dirichlet_platt_scaled_lambda_vec(arb_ptr res, const fmpz_t T, slong A, slong B, slong prec) - void acb_dirichlet_platt_multieval(arb_ptr res, const fmpz_t T, slong A, slong B, const arb_t h, const fmpz_t J, slong K, slong sigma, slong prec) - void acb_dirichlet_platt_multieval_threaded(arb_ptr res, const fmpz_t T, slong A, slong B, const arb_t h, const fmpz_t J, slong K, slong sigma, slong prec) - void acb_dirichlet_platt_ws_interpolation(arb_t res, arf_t deriv, const arb_t t0, arb_srcptr p, const fmpz_t T, slong A, slong B, slong Ns_max, const arb_t H, slong sigma, slong prec) - slong _acb_dirichlet_platt_local_hardy_z_zeros(arb_ptr res, const fmpz_t n, slong len, const fmpz_t T, slong A, slong B, const arb_t h, const fmpz_t J, slong K, slong sigma_grid, slong Ns_max, const arb_t H, slong sigma_interp, slong prec) - slong acb_dirichlet_platt_local_hardy_z_zeros(arb_ptr res, const fmpz_t n, slong len, slong prec) - slong acb_dirichlet_platt_hardy_z_zeros(arb_ptr res, const fmpz_t n, slong len, slong prec) - slong acb_dirichlet_platt_zeta_zeros(acb_ptr res, const fmpz_t n, slong len, slong prec) diff --git a/src/flint/flintlib/functions/acb_elliptic.pxd b/src/flint/flintlib/functions/acb_elliptic.pxd deleted file mode 100644 index a234f6a1..00000000 --- a/src/flint/flintlib/functions/acb_elliptic.pxd +++ /dev/null @@ -1,31 +0,0 @@ -from flint.flintlib.types.acb cimport acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.flint cimport slong - - - -cdef extern from "flint/acb_elliptic.h": - void acb_elliptic_k(acb_t res, const acb_t m, slong prec) - void acb_elliptic_k_jet(acb_ptr res, const acb_t m, slong len, slong prec) - void _acb_elliptic_k_series(acb_ptr res, acb_srcptr m, slong mlen, slong len, slong prec) - void acb_elliptic_k_series(acb_poly_t res, const acb_poly_t m, slong len, slong prec) - void acb_elliptic_e(acb_t res, const acb_t m, slong prec) - void acb_elliptic_pi(acb_t res, const acb_t n, const acb_t m, slong prec) - void acb_elliptic_f(acb_t res, const acb_t phi, const acb_t m, int pi, slong prec) - void acb_elliptic_e_inc(acb_t res, const acb_t phi, const acb_t m, int pi, slong prec) - void acb_elliptic_pi_inc(acb_t res, const acb_t n, const acb_t phi, const acb_t m, int pi, slong prec) - void acb_elliptic_rf(acb_t res, const acb_t x, const acb_t y, const acb_t z, int flags, slong prec) - void acb_elliptic_rg(acb_t res, const acb_t x, const acb_t y, const acb_t z, int flags, slong prec) - void acb_elliptic_rj(acb_t res, const acb_t x, const acb_t y, const acb_t z, const acb_t p, int flags, slong prec) - void acb_elliptic_rj_carlson(acb_t res, const acb_t x, const acb_t y, const acb_t z, const acb_t p, int flags, slong prec) - void acb_elliptic_rj_integration(acb_t res, const acb_t x, const acb_t y, const acb_t z, const acb_t p, int flags, slong prec) - void acb_elliptic_rc1(acb_t res, const acb_t x, slong prec) - void acb_elliptic_p(acb_t res, const acb_t z, const acb_t tau, slong prec) - void acb_elliptic_p_prime(acb_t res, const acb_t z, const acb_t tau, slong prec) - void acb_elliptic_p_jet(acb_ptr res, const acb_t z, const acb_t tau, slong len, slong prec) - void _acb_elliptic_p_series(acb_ptr res, acb_srcptr z, slong zlen, const acb_t tau, slong len, slong prec) - void acb_elliptic_p_series(acb_poly_t res, const acb_poly_t z, const acb_t tau, slong len, slong prec) - void acb_elliptic_invariants(acb_t g2, acb_t g3, const acb_t tau, slong prec) - void acb_elliptic_roots(acb_t e1, acb_t e2, acb_t e3, const acb_t tau, slong prec) - void acb_elliptic_inv_p(acb_t res, const acb_t z, const acb_t tau, slong prec) - void acb_elliptic_zeta(acb_t res, const acb_t z, const acb_t tau, slong prec) - void acb_elliptic_sigma(acb_t res, const acb_t z, const acb_t tau, slong prec) diff --git a/src/flint/flintlib/functions/acb_hypgeom.pxd b/src/flint/flintlib/functions/acb_hypgeom.pxd deleted file mode 100644 index 9fa16412..00000000 --- a/src/flint/flintlib/functions/acb_hypgeom.pxd +++ /dev/null @@ -1,161 +0,0 @@ -from flint.flintlib.types.acb cimport acb_poly_struct, acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.arb cimport mag_t -from flint.flintlib.types.flint cimport slong, ulong - - - -cdef extern from "flint/acb_hypgeom.h": - void acb_hypgeom_rising_ui_forward(acb_t res, const acb_t x, ulong n, slong prec) - void acb_hypgeom_rising_ui_bs(acb_t res, const acb_t x, ulong n, slong prec) - void acb_hypgeom_rising_ui_rs(acb_t res, const acb_t x, ulong n, ulong m, slong prec) - void acb_hypgeom_rising_ui_rec(acb_t res, const acb_t x, ulong n, slong prec) - void acb_hypgeom_rising_ui(acb_t res, const acb_t x, ulong n, slong prec) - void acb_hypgeom_rising(acb_t res, const acb_t x, const acb_t n, slong prec) - void acb_hypgeom_rising_ui_jet_powsum(acb_ptr res, const acb_t x, ulong n, slong len, slong prec) - void acb_hypgeom_rising_ui_jet_bs(acb_ptr res, const acb_t x, ulong n, slong len, slong prec) - void acb_hypgeom_rising_ui_jet_rs(acb_ptr res, const acb_t x, ulong n, ulong m, slong len, slong prec) - void acb_hypgeom_rising_ui_jet(acb_ptr res, const acb_t x, ulong n, slong len, slong prec) - void acb_hypgeom_log_rising_ui(acb_ptr res, const acb_t x, ulong n, slong prec) - void acb_hypgeom_log_rising_ui_jet(acb_ptr res, const acb_t x, ulong n, slong len, slong prec) - void acb_hypgeom_gamma_stirling_sum_horner(acb_t s, const acb_t z, slong N, slong prec) - void acb_hypgeom_gamma_stirling_sum_improved(acb_t s, const acb_t z, slong N, slong K, slong prec) - void acb_hypgeom_gamma_stirling(acb_t res, const acb_t x, int reciprocal, slong prec) - int acb_hypgeom_gamma_taylor(acb_t res, const acb_t x, int reciprocal, slong prec) - void acb_hypgeom_gamma(acb_t res, const acb_t x, slong prec) - void acb_hypgeom_rgamma(acb_t res, const acb_t x, slong prec) - void acb_hypgeom_lgamma(acb_t res, const acb_t x, slong prec) - void acb_hypgeom_pfq_bound_factor(mag_t C, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, ulong n) - slong acb_hypgeom_pfq_choose_n(acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong prec) - void acb_hypgeom_pfq_sum_forward(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong n, slong prec) - void acb_hypgeom_pfq_sum_rs(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong n, slong prec) - void acb_hypgeom_pfq_sum_bs(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong n, slong prec) - void acb_hypgeom_pfq_sum_fme(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong n, slong prec) - void acb_hypgeom_pfq_sum(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong n, slong prec) - void acb_hypgeom_pfq_sum_bs_invz(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t w, slong n, slong prec) - void acb_hypgeom_pfq_sum_invz(acb_t s, acb_t t, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, const acb_t w, slong n, slong prec) - void acb_hypgeom_pfq_direct(acb_t res, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, slong n, slong prec) - void acb_hypgeom_pfq_series_sum_forward(acb_poly_t s, acb_poly_t t, const acb_poly_struct * a, slong p, const acb_poly_struct * b, slong q, const acb_poly_t z, int regularized, slong n, slong len, slong prec) - void acb_hypgeom_pfq_series_sum_bs(acb_poly_t s, acb_poly_t t, const acb_poly_struct * a, slong p, const acb_poly_struct * b, slong q, const acb_poly_t z, int regularized, slong n, slong len, slong prec) - void acb_hypgeom_pfq_series_sum_rs(acb_poly_t s, acb_poly_t t, const acb_poly_struct * a, slong p, const acb_poly_struct * b, slong q, const acb_poly_t z, int regularized, slong n, slong len, slong prec) - void acb_hypgeom_pfq_series_sum(acb_poly_t s, acb_poly_t t, const acb_poly_struct * a, slong p, const acb_poly_struct * b, slong q, const acb_poly_t z, int regularized, slong n, slong len, slong prec) - void acb_hypgeom_pfq_series_direct(acb_poly_t res, const acb_poly_struct * a, slong p, const acb_poly_struct * b, slong q, const acb_poly_t z, int regularized, slong n, slong len, slong prec) - void acb_hypgeom_u_asymp(acb_t res, const acb_t a, const acb_t b, const acb_t z, slong n, slong prec) - int acb_hypgeom_u_use_asymp(const acb_t z, slong prec) - void acb_hypgeom_pfq(acb_t res, acb_srcptr a, slong p, acb_srcptr b, slong q, const acb_t z, int regularized, slong prec) - void acb_hypgeom_u_1f1_series(acb_poly_t res, const acb_poly_t a, const acb_poly_t b, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_u_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, slong prec) - void acb_hypgeom_u(acb_t res, const acb_t a, const acb_t b, const acb_t z, slong prec) - void acb_hypgeom_m_asymp(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec) - void acb_hypgeom_m_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec) - void acb_hypgeom_m(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec) - void acb_hypgeom_1f1(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec) - void acb_hypgeom_0f1_asymp(acb_t res, const acb_t a, const acb_t z, int regularized, slong prec) - void acb_hypgeom_0f1_direct(acb_t res, const acb_t a, const acb_t z, int regularized, slong prec) - void acb_hypgeom_0f1(acb_t res, const acb_t a, const acb_t z, int regularized, slong prec) - void acb_hypgeom_erf_propagated_error(mag_t re, mag_t im, const acb_t z) - void acb_hypgeom_erf_1f1a(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_erf_1f1b(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_erf_asymp(acb_t res, const acb_t z, int complementary, slong prec, slong prec2) - void acb_hypgeom_erf(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_erf_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_erf_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_erfc(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_erfc_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_erfc_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_erfi(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_erfi_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_erfi_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_fresnel(acb_t res1, acb_t res2, const acb_t z, int normalized, slong prec) - void _acb_hypgeom_fresnel_series(acb_ptr res1, acb_ptr res2, acb_srcptr z, slong zlen, int normalized, slong len, slong prec) - void acb_hypgeom_fresnel_series(acb_poly_t res1, acb_poly_t res2, const acb_poly_t z, int normalized, slong len, slong prec) - void acb_hypgeom_bessel_j_deriv_bound(mag_t res, const acb_t nu, const acb_t z, ulong d) - void acb_hypgeom_bessel_j_asymp(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_j_0f1(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_j(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_y(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_jy(acb_t res1, acb_t res2, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_i_asymp(acb_t res, const acb_t nu, const acb_t z, int scaled, slong prec) - void acb_hypgeom_bessel_i_0f1(acb_t res, const acb_t nu, const acb_t z, int scaled, slong prec) - void acb_hypgeom_bessel_i(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_i_scaled(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_k_asymp(acb_t res, const acb_t nu, const acb_t z, int scaled, slong prec) - void acb_hypgeom_bessel_k_0f1_series(acb_poly_t res, const acb_poly_t nu, const acb_poly_t z, int scaled, slong len, slong prec) - void acb_hypgeom_bessel_k_0f1(acb_t res, const acb_t nu, const acb_t z, int scaled, slong prec) - void acb_hypgeom_bessel_k(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_bessel_k_scaled(acb_t res, const acb_t nu, const acb_t z, slong prec) - void acb_hypgeom_airy_direct(acb_t ai, acb_t ai_prime, acb_t bi, acb_t bi_prime, const acb_t z, slong n, slong prec) - void acb_hypgeom_airy_asymp(acb_t ai, acb_t ai_prime, acb_t bi, acb_t bi_prime, const acb_t z, slong n, slong prec) - void acb_hypgeom_airy_bound(mag_t ai, mag_t ai_prime, mag_t bi, mag_t bi_prime, const acb_t z) - void acb_hypgeom_airy(acb_t ai, acb_t ai_prime, acb_t bi, acb_t bi_prime, const acb_t z, slong prec) - void acb_hypgeom_airy_jet(acb_ptr ai, acb_ptr bi, const acb_t z, slong len, slong prec) - void _acb_hypgeom_airy_series(acb_ptr ai, acb_ptr ai_prime, acb_ptr bi, acb_ptr bi_prime, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_airy_series(acb_poly_t ai, acb_poly_t ai_prime, acb_poly_t bi, acb_poly_t bi_prime, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_coulomb(acb_t F, acb_t G, acb_t Hpos, acb_t Hneg, const acb_t l, const acb_t eta, const acb_t z, slong prec) - void acb_hypgeom_coulomb_jet(acb_ptr F, acb_ptr G, acb_ptr Hpos, acb_ptr Hneg, const acb_t l, const acb_t eta, const acb_t z, slong len, slong prec) - void _acb_hypgeom_coulomb_series(acb_ptr F, acb_ptr G, acb_ptr Hpos, acb_ptr Hneg, const acb_t l, const acb_t eta, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_coulomb_series(acb_poly_t F, acb_poly_t G, acb_poly_t Hpos, acb_poly_t Hneg, const acb_t l, const acb_t eta, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_gamma_upper_asymp(acb_t res, const acb_t s, const acb_t z, int regularized, slong prec) - void acb_hypgeom_gamma_upper_1f1a(acb_t res, const acb_t s, const acb_t z, int regularized, slong prec) - void acb_hypgeom_gamma_upper_1f1b(acb_t res, const acb_t s, const acb_t z, int regularized, slong prec) - void acb_hypgeom_gamma_upper_singular(acb_t res, slong s, const acb_t z, int regularized, slong prec) - void acb_hypgeom_gamma_upper(acb_t res, const acb_t s, const acb_t z, int regularized, slong prec) - void _acb_hypgeom_gamma_upper_series(acb_ptr res, const acb_t s, acb_srcptr z, slong zlen, int regularized, slong n, slong prec) - void acb_hypgeom_gamma_upper_series(acb_poly_t res, const acb_t s, const acb_poly_t z, int regularized, slong n, slong prec) - void acb_hypgeom_gamma_lower(acb_t res, const acb_t s, const acb_t z, int regularized, slong prec) - void _acb_hypgeom_gamma_lower_series(acb_ptr res, const acb_t s, acb_srcptr z, slong zlen, int regularized, slong n, slong prec) - void acb_hypgeom_gamma_lower_series(acb_poly_t res, const acb_t s, const acb_poly_t z, int regularized, slong n, slong prec) - void acb_hypgeom_beta_lower(acb_t res, const acb_t a, const acb_t b, const acb_t z, int regularized, slong prec) - void _acb_hypgeom_beta_lower_series(acb_ptr res, const acb_t a, const acb_t b, acb_srcptr z, slong zlen, int regularized, slong n, slong prec) - void acb_hypgeom_beta_lower_series(acb_poly_t res, const acb_t a, const acb_t b, const acb_poly_t z, int regularized, slong n, slong prec) - void acb_hypgeom_expint(acb_t res, const acb_t s, const acb_t z, slong prec) - void acb_hypgeom_ei_asymp(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_ei_2f2(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_ei(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_ei_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_ei_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_si_asymp(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_si_1f2(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_si(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_si_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_si_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_ci_asymp(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_ci_2f3(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_ci(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_ci_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_ci_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_shi(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_shi_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_shi_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_chi_asymp(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_chi_2f3(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_chi(acb_t res, const acb_t z, slong prec) - void _acb_hypgeom_chi_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_hypgeom_chi_series(acb_poly_t res, const acb_poly_t z, slong len, slong prec) - void acb_hypgeom_li(acb_t res, const acb_t z, int offset, slong prec) - void _acb_hypgeom_li_series(acb_ptr res, acb_srcptr z, slong zlen, int offset, slong len, slong prec) - void acb_hypgeom_li_series(acb_poly_t res, const acb_poly_t z, int offset, slong len, slong prec) - void acb_hypgeom_2f1_continuation(acb_t res0, acb_t res1, const acb_t a, const acb_t b, const acb_t c, const acb_t z0, const acb_t z1, const acb_t f0, const acb_t f1, slong prec) - void acb_hypgeom_2f1_series_direct(acb_poly_t res, const acb_poly_t a, const acb_poly_t b, const acb_poly_t c, const acb_poly_t z, int regularized, slong len, slong prec) - void acb_hypgeom_2f1_direct(acb_t res, const acb_t a, const acb_t b, const acb_t c, const acb_t z, int regularized, slong prec) - void acb_hypgeom_2f1_transform(acb_t res, const acb_t a, const acb_t b, const acb_t c, const acb_t z, int flags, int which, slong prec) - void acb_hypgeom_2f1_transform_limit(acb_t res, const acb_t a, const acb_t b, const acb_t c, const acb_t z, int regularized, int which, slong prec) - void acb_hypgeom_2f1_corner(acb_t res, const acb_t a, const acb_t b, const acb_t c, const acb_t z, int regularized, slong prec) - int acb_hypgeom_2f1_choose(const acb_t z) - void acb_hypgeom_2f1(acb_t res, const acb_t a, const acb_t b, const acb_t c, const acb_t z, int flags, slong prec) - void acb_hypgeom_chebyshev_t(acb_t res, const acb_t n, const acb_t z, slong prec) - void acb_hypgeom_chebyshev_u(acb_t res, const acb_t n, const acb_t z, slong prec) - void acb_hypgeom_jacobi_p(acb_t res, const acb_t n, const acb_t a, const acb_t b, const acb_t z, slong prec) - void acb_hypgeom_gegenbauer_c(acb_t res, const acb_t n, const acb_t m, const acb_t z, slong prec) - void acb_hypgeom_laguerre_l(acb_t res, const acb_t n, const acb_t m, const acb_t z, slong prec) - void acb_hypgeom_hermite_h(acb_t res, const acb_t n, const acb_t z, slong prec) - void acb_hypgeom_legendre_p(acb_t res, const acb_t n, const acb_t m, const acb_t z, int type, slong prec) - void acb_hypgeom_legendre_q(acb_t res, const acb_t n, const acb_t m, const acb_t z, int type, slong prec) - void acb_hypgeom_legendre_p_uiui_rec(acb_t res, ulong n, ulong m, const acb_t z, slong prec) - void acb_hypgeom_spherical_y(acb_t res, slong n, slong m, const acb_t theta, const acb_t phi, slong prec) - void acb_hypgeom_dilog_bernoulli(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_dilog_zero_taylor(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_dilog_zero(acb_t res, const acb_t z, slong prec) - void acb_hypgeom_dilog_transform(acb_t res, const acb_t z, int algorithm, slong prec) - void acb_hypgeom_dilog_continuation(acb_t res, const acb_t a, const acb_t z, slong prec) - void acb_hypgeom_dilog_bitburst(acb_t res, acb_t z0, const acb_t z, slong prec) - void acb_hypgeom_dilog(acb_t res, const acb_t z, slong prec) diff --git a/src/flint/flintlib/functions/acb_mat.pxd b/src/flint/flintlib/functions/acb_mat.pxd deleted file mode 100644 index fb810e85..00000000 --- a/src/flint/flintlib/functions/acb_mat.pxd +++ /dev/null @@ -1,130 +0,0 @@ -from flint.flintlib.types.acb cimport acb_mat_t, acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.arb cimport arb_mat_t, arb_t, mag_t -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_mat_t -from flint.flintlib.types.fmpz cimport fmpz_mat_t - -# unknown type FILE - -# .. macro:: acb_mat_entry(mat, i, j) -# .. macro:: acb_mat_nrows(mat) -# .. macro:: acb_mat_ncols(mat) - -cdef extern from "flint/acb_mat.h": - void acb_mat_init(acb_mat_t mat, slong r, slong c) - void acb_mat_clear(acb_mat_t mat) - slong acb_mat_allocated_bytes(const acb_mat_t x) - void acb_mat_window_init(acb_mat_t window, const acb_mat_t mat, slong r1, slong c1, slong r2, slong c2) - void acb_mat_window_clear(acb_mat_t window) - void acb_mat_set(acb_mat_t dest, const acb_mat_t src) - void acb_mat_set_fmpz_mat(acb_mat_t dest, const fmpz_mat_t src) - void acb_mat_set_round_fmpz_mat(acb_mat_t dest, const fmpz_mat_t src, slong prec) - void acb_mat_set_fmpq_mat(acb_mat_t dest, const fmpq_mat_t src, slong prec) - void acb_mat_set_arb_mat(acb_mat_t dest, const arb_mat_t src) - void acb_mat_set_round_arb_mat(acb_mat_t dest, const arb_mat_t src, slong prec) - void acb_mat_get_real(arb_mat_t re, const acb_mat_t mat) - void acb_mat_get_imag(arb_mat_t im, const acb_mat_t mat) - void acb_mat_set_real_imag(acb_mat_t mat, const arb_mat_t re, const arb_mat_t im) - void acb_mat_randtest(acb_mat_t mat, flint_rand_t state, slong prec, slong mag_bits) - void acb_mat_randtest_eig(acb_mat_t mat, flint_rand_t state, acb_srcptr E, slong prec) - void acb_mat_printd(const acb_mat_t mat, slong digits) - # void acb_mat_fprintd(FILE * file, const acb_mat_t mat, slong digits) - int acb_mat_equal(const acb_mat_t mat1, const acb_mat_t mat2) - int acb_mat_overlaps(const acb_mat_t mat1, const acb_mat_t mat2) - int acb_mat_contains(const acb_mat_t mat1, const acb_mat_t mat2) - int acb_mat_contains_fmpz_mat(const acb_mat_t mat1, const fmpz_mat_t mat2) - int acb_mat_contains_fmpq_mat(const acb_mat_t mat1, const fmpq_mat_t mat2) - int acb_mat_eq(const acb_mat_t mat1, const acb_mat_t mat2) - int acb_mat_ne(const acb_mat_t mat1, const acb_mat_t mat2) - int acb_mat_is_real(const acb_mat_t mat) - int acb_mat_is_empty(const acb_mat_t mat) - int acb_mat_is_square(const acb_mat_t mat) - int acb_mat_is_exact(const acb_mat_t mat) - int acb_mat_is_zero(const acb_mat_t mat) - int acb_mat_is_finite(const acb_mat_t mat) - int acb_mat_is_triu(const acb_mat_t mat) - int acb_mat_is_tril(const acb_mat_t mat) - int acb_mat_is_diag(const acb_mat_t mat) - void acb_mat_zero(acb_mat_t mat) - void acb_mat_one(acb_mat_t mat) - void acb_mat_ones(acb_mat_t mat) - void acb_mat_onei(acb_mat_t mat) - void acb_mat_indeterminate(acb_mat_t mat) - void acb_mat_dft(acb_mat_t mat, int type, slong prec) - void acb_mat_transpose(acb_mat_t dest, const acb_mat_t src) - void acb_mat_conjugate_transpose(acb_mat_t dest, const acb_mat_t src) - void acb_mat_conjugate(acb_mat_t dest, const acb_mat_t src) - void acb_mat_bound_inf_norm(mag_t b, const acb_mat_t A) - void acb_mat_frobenius_norm(arb_t res, const acb_mat_t A, slong prec) - void acb_mat_bound_frobenius_norm(mag_t res, const acb_mat_t A) - void acb_mat_neg(acb_mat_t dest, const acb_mat_t src) - void acb_mat_add(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_sub(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_mul_classical(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_mul_threaded(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_mul_reorder(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_mul(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_mul_entrywise(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_sqr_classical(acb_mat_t res, const acb_mat_t mat, slong prec) - void acb_mat_sqr(acb_mat_t res, const acb_mat_t mat, slong prec) - void acb_mat_pow_ui(acb_mat_t res, const acb_mat_t mat, ulong exp, slong prec) - void acb_mat_approx_mul(acb_mat_t res, const acb_mat_t mat1, const acb_mat_t mat2, slong prec) - void acb_mat_scalar_mul_2exp_si(acb_mat_t B, const acb_mat_t A, slong c) - void acb_mat_scalar_addmul_si(acb_mat_t B, const acb_mat_t A, slong c, slong prec) - void acb_mat_scalar_addmul_fmpz(acb_mat_t B, const acb_mat_t A, const fmpz_t c, slong prec) - void acb_mat_scalar_addmul_arb(acb_mat_t B, const acb_mat_t A, const arb_t c, slong prec) - void acb_mat_scalar_addmul_acb(acb_mat_t B, const acb_mat_t A, const acb_t c, slong prec) - void acb_mat_scalar_mul_si(acb_mat_t B, const acb_mat_t A, slong c, slong prec) - void acb_mat_scalar_mul_fmpz(acb_mat_t B, const acb_mat_t A, const fmpz_t c, slong prec) - void acb_mat_scalar_mul_arb(acb_mat_t B, const acb_mat_t A, const arb_t c, slong prec) - void acb_mat_scalar_mul_acb(acb_mat_t B, const acb_mat_t A, const acb_t c, slong prec) - void acb_mat_scalar_div_si(acb_mat_t B, const acb_mat_t A, slong c, slong prec) - void acb_mat_scalar_div_fmpz(acb_mat_t B, const acb_mat_t A, const fmpz_t c, slong prec) - void acb_mat_scalar_div_arb(acb_mat_t B, const acb_mat_t A, const arb_t c, slong prec) - void acb_mat_scalar_div_acb(acb_mat_t B, const acb_mat_t A, const acb_t c, slong prec) - void _acb_mat_vector_mul_row(acb_ptr res, acb_srcptr v, const acb_mat_t A, slong prec) - void _acb_mat_vector_mul_col(acb_ptr res, const acb_mat_t A, acb_srcptr v, slong prec) - void acb_mat_vector_mul_row(acb_ptr res, acb_srcptr v, const acb_mat_t A, slong prec) - void acb_mat_vector_mul_col(acb_ptr res, const acb_mat_t A, acb_srcptr v, slong prec) - int acb_mat_lu_classical(slong * perm, acb_mat_t LU, const acb_mat_t A, slong prec) - int acb_mat_lu_recursive(slong * perm, acb_mat_t LU, const acb_mat_t A, slong prec) - int acb_mat_lu(slong * perm, acb_mat_t LU, const acb_mat_t A, slong prec) - void acb_mat_solve_tril_classical(acb_mat_t X, const acb_mat_t L, const acb_mat_t B, int unit, slong prec) - void acb_mat_solve_tril_recursive(acb_mat_t X, const acb_mat_t L, const acb_mat_t B, int unit, slong prec) - void acb_mat_solve_tril(acb_mat_t X, const acb_mat_t L, const acb_mat_t B, int unit, slong prec) - void acb_mat_solve_triu_classical(acb_mat_t X, const acb_mat_t U, const acb_mat_t B, int unit, slong prec) - void acb_mat_solve_triu_recursive(acb_mat_t X, const acb_mat_t U, const acb_mat_t B, int unit, slong prec) - void acb_mat_solve_triu(acb_mat_t X, const acb_mat_t U, const acb_mat_t B, int unit, slong prec) - void acb_mat_solve_lu_precomp(acb_mat_t X, const slong * perm, const acb_mat_t LU, const acb_mat_t B, slong prec) - int acb_mat_solve(acb_mat_t X, const acb_mat_t A, const acb_mat_t B, slong prec) - int acb_mat_solve_lu(acb_mat_t X, const acb_mat_t A, const acb_mat_t B, slong prec) - int acb_mat_solve_precond(acb_mat_t X, const acb_mat_t A, const acb_mat_t B, slong prec) - int acb_mat_inv(acb_mat_t X, const acb_mat_t A, slong prec) - void acb_mat_det_lu(acb_t det, const acb_mat_t A, slong prec) - void acb_mat_det_precond(acb_t det, const acb_mat_t A, slong prec) - void acb_mat_det(acb_t det, const acb_mat_t A, slong prec) - void acb_mat_approx_solve_triu(acb_mat_t X, const acb_mat_t U, const acb_mat_t B, int unit, slong prec) - void acb_mat_approx_solve_tril(acb_mat_t X, const acb_mat_t L, const acb_mat_t B, int unit, slong prec) - int acb_mat_approx_lu(slong * P, acb_mat_t LU, const acb_mat_t A, slong prec) - void acb_mat_approx_solve_lu_precomp(acb_mat_t X, const slong * perm, const acb_mat_t A, const acb_mat_t B, slong prec) - int acb_mat_approx_solve(acb_mat_t X, const acb_mat_t A, const acb_mat_t B, slong prec) - int acb_mat_approx_inv(acb_mat_t X, const acb_mat_t A, slong prec) - void _acb_mat_charpoly(acb_ptr poly, const acb_mat_t mat, slong prec) - void acb_mat_charpoly(acb_poly_t poly, const acb_mat_t mat, slong prec) - void _acb_mat_companion(acb_mat_t mat, acb_srcptr poly, slong prec) - void acb_mat_companion(acb_mat_t mat, const acb_poly_t poly, slong prec) - void acb_mat_exp_taylor_sum(acb_mat_t S, const acb_mat_t A, slong N, slong prec) - void acb_mat_exp(acb_mat_t B, const acb_mat_t A, slong prec) - void acb_mat_trace(acb_t trace, const acb_mat_t mat, slong prec) - void _acb_mat_diag_prod(acb_t res, const acb_mat_t mat, slong a, slong b, slong prec) - void acb_mat_diag_prod(acb_t res, const acb_mat_t mat, slong prec) - void acb_mat_get_mid(acb_mat_t B, const acb_mat_t A) - void acb_mat_add_error_mag(acb_mat_t mat, const mag_t err) - int acb_mat_approx_eig_qr(acb_ptr E, acb_mat_t L, acb_mat_t R, const acb_mat_t A, const mag_t tol, slong maxiter, slong prec) - void acb_mat_eig_global_enclosure(mag_t eps, const acb_mat_t A, acb_srcptr E, const acb_mat_t R, slong prec) - void acb_mat_eig_enclosure_rump(acb_t lambda_, acb_mat_t J, acb_mat_t R, const acb_mat_t A, const acb_t lambda_approx, const acb_mat_t R_approx, slong prec) - int acb_mat_eig_simple_rump(acb_ptr E, acb_mat_t L, acb_mat_t R, const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec) - int acb_mat_eig_simple_vdhoeven_mourrain(acb_ptr E, acb_mat_t L, acb_mat_t R, const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec) - int acb_mat_eig_simple(acb_ptr E, acb_mat_t L, acb_mat_t R, const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec) - int acb_mat_eig_multiple_rump(acb_ptr E, const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec) - int acb_mat_eig_multiple(acb_ptr E, const acb_mat_t A, acb_srcptr E_approx, const acb_mat_t R_approx, slong prec) diff --git a/src/flint/flintlib/functions/acb_modular.pxd b/src/flint/flintlib/functions/acb_modular.pxd deleted file mode 100644 index d93f9a8e..00000000 --- a/src/flint/flintlib/functions/acb_modular.pxd +++ /dev/null @@ -1,55 +0,0 @@ -from flint.flintlib.types.acb cimport acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.arf cimport arf_t -from flint.flintlib.types.flint cimport flint_rand_t, slong -from flint.flintlib.types.fmpz cimport fmpz_poly_t - -# unknown type FILE -# unknown type psl2z_t - - -cdef extern from "flint/acb_modular.h": - # void psl2z_init(psl2z_t g) - # void psl2z_clear(psl2z_t g) - # void psl2z_swap(psl2z_t f, psl2z_t g) - # void psl2z_set(psl2z_t f, const psl2z_t g) - # void psl2z_one(psl2z_t g) - # int psl2z_is_one(const psl2z_t g) - # void psl2z_print(const psl2z_t g) - # void psl2z_fprint(FILE * file, const psl2z_t g) - # int psl2z_equal(const psl2z_t f, const psl2z_t g) - # void psl2z_mul(psl2z_t h, const psl2z_t f, const psl2z_t g) - # void psl2z_inv(psl2z_t h, const psl2z_t g) - # int psl2z_is_correct(const psl2z_t g) - # void psl2z_randtest(psl2z_t g, flint_rand_t state, slong bits) - # void acb_modular_transform(acb_t w, const psl2z_t g, const acb_t z, slong prec) - # void acb_modular_fundamental_domain_approx_d(psl2z_t g, double x, double y, double one_minus_eps) - # void acb_modular_fundamental_domain_approx_arf(psl2z_t g, const arf_t x, const arf_t y, const arf_t one_minus_eps, slong prec) - # void acb_modular_fundamental_domain_approx(acb_t w, psl2z_t g, const acb_t z, const arf_t one_minus_eps, slong prec) - int acb_modular_is_in_fundamental_domain(const acb_t z, const arf_t tol, slong prec) - void acb_modular_fill_addseq(slong * tab, slong len) - # void acb_modular_theta_transform(int * R, int * S, int * C, const psl2z_t g) - void acb_modular_addseq_theta(slong * exponents, slong * aindex, slong * bindex, slong num) - void acb_modular_theta_sum(acb_ptr theta1, acb_ptr theta2, acb_ptr theta3, acb_ptr theta4, const acb_t w, int w_is_unit, const acb_t q, slong len, slong prec) - void acb_modular_theta_const_sum_basecase(acb_t theta2, acb_t theta3, acb_t theta4, const acb_t q, slong N, slong prec) - void acb_modular_theta_const_sum_rs(acb_t theta2, acb_t theta3, acb_t theta4, const acb_t q, slong N, slong prec) - void acb_modular_theta_const_sum(acb_t theta2, acb_t theta3, acb_t theta4, const acb_t q, slong prec) - void acb_modular_theta_notransform(acb_t theta1, acb_t theta2, acb_t theta3, acb_t theta4, const acb_t z, const acb_t tau, slong prec) - void acb_modular_theta(acb_t theta1, acb_t theta2, acb_t theta3, acb_t theta4, const acb_t z, const acb_t tau, slong prec) - void acb_modular_theta_jet_notransform(acb_ptr theta1, acb_ptr theta2, acb_ptr theta3, acb_ptr theta4, const acb_t z, const acb_t tau, slong len, slong prec) - void acb_modular_theta_jet(acb_ptr theta1, acb_ptr theta2, acb_ptr theta3, acb_ptr theta4, const acb_t z, const acb_t tau, slong len, slong prec) - void _acb_modular_theta_series(acb_ptr theta1, acb_ptr theta2, acb_ptr theta3, acb_ptr theta4, acb_srcptr z, slong zlen, const acb_t tau, slong len, slong prec) - void acb_modular_theta_series(acb_poly_t theta1, acb_poly_t theta2, acb_poly_t theta3, acb_poly_t theta4, const acb_poly_t z, const acb_t tau, slong len, slong prec) - void acb_modular_addseq_eta(slong * exponents, slong * aindex, slong * bindex, slong num) - void acb_modular_eta_sum(acb_t eta, const acb_t q, slong prec) - # int acb_modular_epsilon_arg(const psl2z_t g) - void acb_modular_eta(acb_t r, const acb_t tau, slong prec) - void acb_modular_j(acb_t r, const acb_t tau, slong prec) - void acb_modular_lambda(acb_t r, const acb_t tau, slong prec) - void acb_modular_delta(acb_t r, const acb_t tau, slong prec) - void acb_modular_eisenstein(acb_ptr r, const acb_t tau, slong len, slong prec) - void acb_modular_elliptic_k(acb_t w, const acb_t m, slong prec) - void acb_modular_elliptic_k_cpx(acb_ptr w, const acb_t m, slong len, slong prec) - void acb_modular_elliptic_e(acb_t w, const acb_t m, slong prec) - void acb_modular_elliptic_p(acb_t wp, const acb_t z, const acb_t tau, slong prec) - void acb_modular_elliptic_p_zpx(acb_ptr wp, const acb_t z, const acb_t tau, slong len, slong prec) - void acb_modular_hilbert_class_poly(fmpz_poly_t res, slong D) diff --git a/src/flint/flintlib/functions/acb_poly.pxd b/src/flint/flintlib/functions/acb_poly.pxd deleted file mode 100644 index ce87060d..00000000 --- a/src/flint/flintlib/functions/acb_poly.pxd +++ /dev/null @@ -1,244 +0,0 @@ -from flint.flintlib.types.acb cimport acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.arb cimport arb_poly_t, arb_ptr, mag_t -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_poly_t -from flint.flintlib.types.fmpz cimport fmpz_poly_t - -# unknown type FILE - -# .. macro:: acb_poly_get_coeff_ptr(poly, n) - -cdef extern from "flint/acb_poly.h": - void acb_poly_init(acb_poly_t poly) - void acb_poly_clear(acb_poly_t poly) - void acb_poly_fit_length(acb_poly_t poly, slong len) - void _acb_poly_set_length(acb_poly_t poly, slong len) - void _acb_poly_normalise(acb_poly_t poly) - void acb_poly_swap(acb_poly_t poly1, acb_poly_t poly2) - slong acb_poly_allocated_bytes(const acb_poly_t x) - slong acb_poly_length(const acb_poly_t poly) - slong acb_poly_degree(const acb_poly_t poly) - int acb_poly_is_zero(const acb_poly_t poly) - int acb_poly_is_one(const acb_poly_t poly) - int acb_poly_is_x(const acb_poly_t poly) - void acb_poly_zero(acb_poly_t poly) - void acb_poly_one(acb_poly_t poly) - void acb_poly_set(acb_poly_t dest, const acb_poly_t src) - void acb_poly_set_round(acb_poly_t dest, const acb_poly_t src, slong prec) - void acb_poly_set_trunc(acb_poly_t dest, const acb_poly_t src, slong n) - void acb_poly_set_trunc_round(acb_poly_t dest, const acb_poly_t src, slong n, slong prec) - void acb_poly_set_coeff_si(acb_poly_t poly, slong n, slong c) - void acb_poly_set_coeff_acb(acb_poly_t poly, slong n, const acb_t c) - void acb_poly_get_coeff_acb(acb_t v, const acb_poly_t poly, slong n) - void _acb_poly_shift_right(acb_ptr res, acb_srcptr poly, slong len, slong n) - void acb_poly_shift_right(acb_poly_t res, const acb_poly_t poly, slong n) - void _acb_poly_shift_left(acb_ptr res, acb_srcptr poly, slong len, slong n) - void acb_poly_shift_left(acb_poly_t res, const acb_poly_t poly, slong n) - void acb_poly_truncate(acb_poly_t poly, slong n) - slong acb_poly_valuation(const acb_poly_t poly) - void acb_poly_printd(const acb_poly_t poly, slong digits) - # void acb_poly_fprintd(FILE * file, const acb_poly_t poly, slong digits) - void acb_poly_randtest(acb_poly_t poly, flint_rand_t state, slong len, slong prec, slong mag_bits) - int acb_poly_equal(const acb_poly_t A, const acb_poly_t B) - int acb_poly_contains(const acb_poly_t poly1, const acb_poly_t poly2) - int acb_poly_contains_fmpz_poly(const acb_poly_t poly1, const fmpz_poly_t poly2) - int acb_poly_contains_fmpq_poly(const acb_poly_t poly1, const fmpq_poly_t poly2) - int _acb_poly_overlaps(acb_srcptr poly1, slong len1, acb_srcptr poly2, slong len2) - int acb_poly_overlaps(const acb_poly_t poly1, const acb_poly_t poly2) - int acb_poly_get_unique_fmpz_poly(fmpz_poly_t z, const acb_poly_t x) - int acb_poly_is_real(const acb_poly_t poly) - void acb_poly_set_fmpz_poly(acb_poly_t poly, const fmpz_poly_t re, slong prec) - void acb_poly_set2_fmpz_poly(acb_poly_t poly, const fmpz_poly_t re, const fmpz_poly_t im, slong prec) - void acb_poly_set_arb_poly(acb_poly_t poly, const arb_poly_t re) - void acb_poly_set2_arb_poly(acb_poly_t poly, const arb_poly_t re, const arb_poly_t im) - void acb_poly_set_fmpq_poly(acb_poly_t poly, const fmpq_poly_t re, slong prec) - void acb_poly_set2_fmpq_poly(acb_poly_t poly, const fmpq_poly_t re, const fmpq_poly_t im, slong prec) - void acb_poly_set_acb(acb_poly_t poly, const acb_t src) - void acb_poly_set_si(acb_poly_t poly, slong src) - void _acb_poly_majorant(arb_ptr res, acb_srcptr poly, slong len, slong prec) - void acb_poly_majorant(arb_poly_t res, const acb_poly_t poly, slong prec) - void _acb_poly_add(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong prec) - void acb_poly_add(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong prec) - void acb_poly_add_si(acb_poly_t C, const acb_poly_t A, slong B, slong prec) - void _acb_poly_sub(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong prec) - void acb_poly_sub(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong prec) - void acb_poly_add_series(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong len, slong prec) - void acb_poly_sub_series(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong len, slong prec) - void acb_poly_neg(acb_poly_t C, const acb_poly_t A) - void acb_poly_scalar_mul_2exp_si(acb_poly_t C, const acb_poly_t A, slong c) - void acb_poly_scalar_mul(acb_poly_t C, const acb_poly_t A, const acb_t c, slong prec) - void acb_poly_scalar_div(acb_poly_t C, const acb_poly_t A, const acb_t c, slong prec) - void _acb_poly_mullow_classical(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong n, slong prec) - void _acb_poly_mullow_transpose(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong n, slong prec) - void _acb_poly_mullow_transpose_gauss(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong n, slong prec) - void _acb_poly_mullow(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong n, slong prec) - void acb_poly_mullow_classical(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong n, slong prec) - void acb_poly_mullow_transpose(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong n, slong prec) - void acb_poly_mullow_transpose_gauss(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong n, slong prec) - void acb_poly_mullow(acb_poly_t C, const acb_poly_t A, const acb_poly_t B, slong n, slong prec) - void _acb_poly_mul(acb_ptr C, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong prec) - void acb_poly_mul(acb_poly_t C, const acb_poly_t A1, const acb_poly_t B2, slong prec) - void _acb_poly_inv_series(acb_ptr Qinv, acb_srcptr Q, slong Qlen, slong len, slong prec) - void acb_poly_inv_series(acb_poly_t Qinv, const acb_poly_t Q, slong n, slong prec) - void _acb_poly_div_series(acb_ptr Q, acb_srcptr A, slong Alen, acb_srcptr B, slong Blen, slong n, slong prec) - void acb_poly_div_series(acb_poly_t Q, const acb_poly_t A, const acb_poly_t B, slong n, slong prec) - void _acb_poly_div(acb_ptr Q, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong prec) - void _acb_poly_rem(acb_ptr R, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong prec) - void _acb_poly_divrem(acb_ptr Q, acb_ptr R, acb_srcptr A, slong lenA, acb_srcptr B, slong lenB, slong prec) - int acb_poly_divrem(acb_poly_t Q, acb_poly_t R, const acb_poly_t A, const acb_poly_t B, slong prec) - void _acb_poly_div_root(acb_ptr Q, acb_t R, acb_srcptr A, slong len, const acb_t c, slong prec) - void _acb_poly_taylor_shift(acb_ptr g, const acb_t c, slong n, slong prec) - void acb_poly_taylor_shift(acb_poly_t g, const acb_poly_t f, const acb_t c, slong prec) - void _acb_poly_compose(acb_ptr res, acb_srcptr poly1, slong len1, acb_srcptr poly2, slong len2, slong prec) - void acb_poly_compose(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong prec) - void _acb_poly_compose_series(acb_ptr res, acb_srcptr poly1, slong len1, acb_srcptr poly2, slong len2, slong n, slong prec) - void acb_poly_compose_series(acb_poly_t res, const acb_poly_t poly1, const acb_poly_t poly2, slong n, slong prec) - void _acb_poly_revert_series(acb_ptr h, acb_srcptr f, slong flen, slong n, slong prec) - void acb_poly_revert_series(acb_poly_t h, const acb_poly_t f, slong n, slong prec) - void _acb_poly_evaluate_horner(acb_t y, acb_srcptr f, slong len, const acb_t x, slong prec) - void acb_poly_evaluate_horner(acb_t y, const acb_poly_t f, const acb_t x, slong prec) - void _acb_poly_evaluate_rectangular(acb_t y, acb_srcptr f, slong len, const acb_t x, slong prec) - void acb_poly_evaluate_rectangular(acb_t y, const acb_poly_t f, const acb_t x, slong prec) - void _acb_poly_evaluate(acb_t y, acb_srcptr f, slong len, const acb_t x, slong prec) - void acb_poly_evaluate(acb_t y, const acb_poly_t f, const acb_t x, slong prec) - void _acb_poly_evaluate2_horner(acb_t y, acb_t z, acb_srcptr f, slong len, const acb_t x, slong prec) - void acb_poly_evaluate2_horner(acb_t y, acb_t z, const acb_poly_t f, const acb_t x, slong prec) - void _acb_poly_evaluate2_rectangular(acb_t y, acb_t z, acb_srcptr f, slong len, const acb_t x, slong prec) - void acb_poly_evaluate2_rectangular(acb_t y, acb_t z, const acb_poly_t f, const acb_t x, slong prec) - void _acb_poly_evaluate2(acb_t y, acb_t z, acb_srcptr f, slong len, const acb_t x, slong prec) - void acb_poly_evaluate2(acb_t y, acb_t z, const acb_poly_t f, const acb_t x, slong prec) - void _acb_poly_product_roots(acb_ptr poly, acb_srcptr xs, slong n, slong prec) - void acb_poly_product_roots(acb_poly_t poly, acb_srcptr xs, slong n, slong prec) - acb_ptr * _acb_poly_tree_alloc(slong len) - void _acb_poly_tree_free(acb_ptr * tree, slong len) - void _acb_poly_tree_build(acb_ptr * tree, acb_srcptr roots, slong len, slong prec) - void _acb_poly_evaluate_vec_iter(acb_ptr ys, acb_srcptr poly, slong plen, acb_srcptr xs, slong n, slong prec) - void acb_poly_evaluate_vec_iter(acb_ptr ys, const acb_poly_t poly, acb_srcptr xs, slong n, slong prec) - void _acb_poly_evaluate_vec_fast_precomp(acb_ptr vs, acb_srcptr poly, slong plen, acb_ptr * tree, slong len, slong prec) - void _acb_poly_evaluate_vec_fast(acb_ptr ys, acb_srcptr poly, slong plen, acb_srcptr xs, slong n, slong prec) - void acb_poly_evaluate_vec_fast(acb_ptr ys, const acb_poly_t poly, acb_srcptr xs, slong n, slong prec) - void _acb_poly_interpolate_newton(acb_ptr poly, acb_srcptr xs, acb_srcptr ys, slong n, slong prec) - void acb_poly_interpolate_newton(acb_poly_t poly, acb_srcptr xs, acb_srcptr ys, slong n, slong prec) - void _acb_poly_interpolate_barycentric(acb_ptr poly, acb_srcptr xs, acb_srcptr ys, slong n, slong prec) - void acb_poly_interpolate_barycentric(acb_poly_t poly, acb_srcptr xs, acb_srcptr ys, slong n, slong prec) - void _acb_poly_interpolation_weights(acb_ptr w, acb_ptr * tree, slong len, slong prec) - void _acb_poly_interpolate_fast_precomp(acb_ptr poly, acb_srcptr ys, acb_ptr * tree, acb_srcptr weights, slong len, slong prec) - void _acb_poly_interpolate_fast(acb_ptr poly, acb_srcptr xs, acb_srcptr ys, slong len, slong prec) - void acb_poly_interpolate_fast(acb_poly_t poly, acb_srcptr xs, acb_srcptr ys, slong n, slong prec) - void _acb_poly_derivative(acb_ptr res, acb_srcptr poly, slong len, slong prec) - void acb_poly_derivative(acb_poly_t res, const acb_poly_t poly, slong prec) - void _acb_poly_nth_derivative(acb_ptr res, acb_srcptr poly, ulong n, slong len, slong prec) - void acb_poly_nth_derivative(acb_poly_t res, const acb_poly_t poly, ulong n, slong prec) - void _acb_poly_integral(acb_ptr res, acb_srcptr poly, slong len, slong prec) - void acb_poly_integral(acb_poly_t res, const acb_poly_t poly, slong prec) - void _acb_poly_borel_transform(acb_ptr res, acb_srcptr poly, slong len, slong prec) - void acb_poly_borel_transform(acb_poly_t res, const acb_poly_t poly, slong prec) - void _acb_poly_inv_borel_transform(acb_ptr res, acb_srcptr poly, slong len, slong prec) - void acb_poly_inv_borel_transform(acb_poly_t res, const acb_poly_t poly, slong prec) - void _acb_poly_binomial_transform_basecase(acb_ptr b, acb_srcptr a, slong alen, slong len, slong prec) - void acb_poly_binomial_transform_basecase(acb_poly_t b, const acb_poly_t a, slong len, slong prec) - void _acb_poly_binomial_transform_convolution(acb_ptr b, acb_srcptr a, slong alen, slong len, slong prec) - void acb_poly_binomial_transform_convolution(acb_poly_t b, const acb_poly_t a, slong len, slong prec) - void _acb_poly_binomial_transform(acb_ptr b, acb_srcptr a, slong alen, slong len, slong prec) - void acb_poly_binomial_transform(acb_poly_t b, const acb_poly_t a, slong len, slong prec) - void _acb_poly_graeffe_transform(acb_ptr b, acb_srcptr a, slong len, slong prec) - void acb_poly_graeffe_transform(acb_poly_t b, const acb_poly_t a, slong prec) - void _acb_poly_pow_ui_trunc_binexp(acb_ptr res, acb_srcptr f, slong flen, ulong exp, slong len, slong prec) - void acb_poly_pow_ui_trunc_binexp(acb_poly_t res, const acb_poly_t poly, ulong exp, slong len, slong prec) - void _acb_poly_pow_ui(acb_ptr res, acb_srcptr f, slong flen, ulong exp, slong prec) - void acb_poly_pow_ui(acb_poly_t res, const acb_poly_t poly, ulong exp, slong prec) - void _acb_poly_pow_series(acb_ptr h, acb_srcptr f, slong flen, acb_srcptr g, slong glen, slong len, slong prec) - void acb_poly_pow_series(acb_poly_t h, const acb_poly_t f, const acb_poly_t g, slong len, slong prec) - void _acb_poly_pow_acb_series(acb_ptr h, acb_srcptr f, slong flen, const acb_t g, slong len, slong prec) - void acb_poly_pow_acb_series(acb_poly_t h, const acb_poly_t f, const acb_t g, slong len, slong prec) - void _acb_poly_sqrt_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sqrt_series(acb_poly_t g, const acb_poly_t h, slong n, slong prec) - void _acb_poly_rsqrt_series(acb_ptr g, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_rsqrt_series(acb_poly_t g, const acb_poly_t h, slong n, slong prec) - void _acb_poly_log_series(acb_ptr res, acb_srcptr f, slong flen, slong n, slong prec) - void acb_poly_log_series(acb_poly_t res, const acb_poly_t f, slong n, slong prec) - void _acb_poly_log1p_series(acb_ptr res, acb_srcptr f, slong flen, slong n, slong prec) - void acb_poly_log1p_series(acb_poly_t res, const acb_poly_t f, slong n, slong prec) - void _acb_poly_atan_series(acb_ptr res, acb_srcptr f, slong flen, slong n, slong prec) - void acb_poly_atan_series(acb_poly_t res, const acb_poly_t f, slong n, slong prec) - void _acb_poly_exp_series_basecase(acb_ptr f, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_exp_series_basecase(acb_poly_t f, const acb_poly_t h, slong n, slong prec) - void _acb_poly_exp_series(acb_ptr f, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_exp_series(acb_poly_t f, const acb_poly_t h, slong n, slong prec) - void _acb_poly_exp_pi_i_series(acb_ptr f, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_exp_pi_i_series(acb_poly_t f, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sin_cos_series(acb_ptr s, acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sin_cos_series(acb_poly_t s, acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sin_series(acb_ptr s, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sin_series(acb_poly_t s, const acb_poly_t h, slong n, slong prec) - void _acb_poly_cos_series(acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_cos_series(acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_tan_series(acb_ptr g, acb_srcptr h, slong hlen, slong len, slong prec) - void acb_poly_tan_series(acb_poly_t g, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sin_cos_pi_series(acb_ptr s, acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sin_cos_pi_series(acb_poly_t s, acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sin_pi_series(acb_ptr s, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sin_pi_series(acb_poly_t s, const acb_poly_t h, slong n, slong prec) - void _acb_poly_cos_pi_series(acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_cos_pi_series(acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_cot_pi_series(acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_cot_pi_series(acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sinh_cosh_series_basecase(acb_ptr s, acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sinh_cosh_series_basecase(acb_poly_t s, acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sinh_cosh_series_exponential(acb_ptr s, acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sinh_cosh_series_exponential(acb_poly_t s, acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sinh_cosh_series(acb_ptr s, acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sinh_cosh_series(acb_poly_t s, acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sinh_series(acb_ptr s, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sinh_series(acb_poly_t s, const acb_poly_t h, slong n, slong prec) - void _acb_poly_cosh_series(acb_ptr c, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_cosh_series(acb_poly_t c, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sinc_series(acb_ptr s, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sinc_series(acb_poly_t s, const acb_poly_t h, slong n, slong prec) - void _acb_poly_sinc_pi_series(acb_ptr s, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_sinc_pi_series(acb_poly_t s, const acb_poly_t h, slong n, slong prec) - void _acb_poly_lambertw_series(acb_ptr res, acb_srcptr z, slong zlen, const fmpz_t k, int flags, slong len, slong prec) - void acb_poly_lambertw_series(acb_poly_t res, const acb_poly_t z, const fmpz_t k, int flags, slong len, slong prec) - void _acb_poly_gamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_gamma_series(acb_poly_t res, const acb_poly_t h, slong n, slong prec) - void _acb_poly_rgamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_rgamma_series(acb_poly_t res, const acb_poly_t h, slong n, slong prec) - void _acb_poly_lgamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_lgamma_series(acb_poly_t res, const acb_poly_t h, slong n, slong prec) - void _acb_poly_digamma_series(acb_ptr res, acb_srcptr h, slong hlen, slong n, slong prec) - void acb_poly_digamma_series(acb_poly_t res, const acb_poly_t h, slong n, slong prec) - void _acb_poly_rising_ui_series(acb_ptr res, acb_srcptr f, slong flen, ulong r, slong trunc, slong prec) - void acb_poly_rising_ui_series(acb_poly_t res, const acb_poly_t f, ulong r, slong trunc, slong prec) - void _acb_poly_powsum_series_naive(acb_ptr z, const acb_t s, const acb_t a, const acb_t q, slong n, slong len, slong prec) - void _acb_poly_powsum_series_naive_threaded(acb_ptr z, const acb_t s, const acb_t a, const acb_t q, slong n, slong len, slong prec) - void _acb_poly_powsum_one_series_sieved(acb_ptr z, const acb_t s, slong n, slong len, slong prec) - void _acb_poly_zeta_em_choose_param(mag_t bound, ulong * N, ulong * M, const acb_t s, const acb_t a, slong d, slong target, slong prec) - void _acb_poly_zeta_em_bound1(mag_t bound, const acb_t s, const acb_t a, slong N, slong M, slong d, slong wp) - void _acb_poly_zeta_em_bound(arb_ptr vec, const acb_t s, const acb_t a, ulong N, ulong M, slong d, slong wp) - void _acb_poly_zeta_em_tail_naive(acb_ptr z, const acb_t s, const acb_t Na, acb_srcptr Nasx, slong M, slong len, slong prec) - void _acb_poly_zeta_em_tail_bsplit(acb_ptr z, const acb_t s, const acb_t Na, acb_srcptr Nasx, slong M, slong len, slong prec) - void _acb_poly_zeta_em_sum(acb_ptr z, const acb_t s, const acb_t a, int deflate, ulong N, ulong M, slong d, slong prec) - void _acb_poly_zeta_cpx_series(acb_ptr z, const acb_t s, const acb_t a, int deflate, slong d, slong prec) - void _acb_poly_zeta_series(acb_ptr res, acb_srcptr h, slong hlen, const acb_t a, int deflate, slong len, slong prec) - void acb_poly_zeta_series(acb_poly_t res, const acb_poly_t f, const acb_t a, int deflate, slong n, slong prec) - void _acb_poly_polylog_cpx_small(acb_ptr w, const acb_t s, const acb_t z, slong len, slong prec) - void _acb_poly_polylog_cpx_zeta(acb_ptr w, const acb_t s, const acb_t z, slong len, slong prec) - void _acb_poly_polylog_cpx(acb_ptr w, const acb_t s, const acb_t z, slong len, slong prec) - void _acb_poly_polylog_series(acb_ptr w, acb_srcptr s, slong slen, const acb_t z, slong len, slong prec) - void acb_poly_polylog_series(acb_poly_t w, const acb_poly_t s, const acb_t z, slong len, slong prec) - void _acb_poly_erf_series(acb_ptr res, acb_srcptr z, slong zlen, slong n, slong prec) - void acb_poly_erf_series(acb_poly_t res, const acb_poly_t z, slong n, slong prec) - void _acb_poly_agm1_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_poly_agm1_series(acb_poly_t res, const acb_poly_t z, slong n, slong prec) - void _acb_poly_elliptic_k_series(acb_ptr res, acb_srcptr z, slong zlen, slong len, slong prec) - void acb_poly_elliptic_k_series(acb_poly_t res, const acb_poly_t z, slong n, slong prec) - void _acb_poly_elliptic_p_series(acb_ptr res, acb_srcptr z, slong zlen, const acb_t tau, slong len, slong prec) - void acb_poly_elliptic_p_series(acb_poly_t res, const acb_poly_t z, const acb_t tau, slong n, slong prec) - void _acb_poly_root_bound_fujiwara(mag_t bound, acb_srcptr poly, slong len) - void acb_poly_root_bound_fujiwara(mag_t bound, acb_poly_t poly) - void _acb_poly_root_inclusion(acb_t r, const acb_t m, acb_srcptr poly, acb_srcptr polyder, slong len, slong prec) - slong _acb_poly_validate_roots(acb_ptr roots, acb_srcptr poly, slong len, slong prec) - slong _acb_poly_find_roots(acb_ptr roots, acb_srcptr poly, acb_srcptr initial, slong len, slong maxiter, slong prec) - slong acb_poly_find_roots(acb_ptr roots, const acb_poly_t poly, acb_srcptr initial, slong maxiter, slong prec) - int _acb_poly_validate_real_roots(acb_srcptr roots, acb_srcptr poly, slong len, slong prec) - int acb_poly_validate_real_roots(acb_srcptr roots, const acb_poly_t poly, slong prec) diff --git a/src/flint/flintlib/functions/acb_theta.pxd b/src/flint/flintlib/functions/acb_theta.pxd deleted file mode 100644 index fa4a6713..00000000 --- a/src/flint/flintlib/functions/acb_theta.pxd +++ /dev/null @@ -1,123 +0,0 @@ -from flint.flintlib.types.acb cimport acb_mat_t, acb_poly_struct, acb_poly_t, acb_ptr, acb_srcptr, acb_t -from flint.flintlib.types.acb_theta cimport acb_theta_eld_t -from flint.flintlib.types.arb cimport arb_mat_t, arb_ptr, arb_srcptr, arb_t -from flint.flintlib.types.arf cimport arf_t -from flint.flintlib.types.flint cimport flint_rand_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_mat_struct, fmpz_mat_t - -# unknown type acb_theta_ctx_tau_t -# unknown type acb_theta_ctx_z_struct -# unknown type acb_theta_ctx_z_t -# unknown type acb_theta_sum_worker_t - - -cdef extern from "flint/acb_theta.h": - ulong acb_theta_char_set_slong_vec(const slong * vec, slong len) - void acb_theta_one(acb_t th, acb_srcptr z, const acb_mat_t tau, ulong ab, slong prec) - void acb_theta_all(acb_ptr th, acb_srcptr z, const acb_mat_t tau, int sqr, slong prec) - void acb_theta_jet(acb_ptr th, acb_srcptr zs, slong nb, const acb_mat_t tau, slong ord, ulong ab, int all, int sqr, slong prec) - slong sp2gz_dim(const fmpz_mat_t mat) - void sp2gz_set_blocks(fmpz_mat_t mat, const fmpz_mat_t alpha, const fmpz_mat_t beta, const fmpz_mat_t gamma, const fmpz_mat_t delta) - void sp2gz_j(fmpz_mat_t mat) - void sp2gz_block_diag(fmpz_mat_t mat, const fmpz_mat_t U) - void sp2gz_trig(fmpz_mat_t mat, const fmpz_mat_t S) - void sp2gz_embed(fmpz_mat_t res, const fmpz_mat_t mat) - void sp2gz_restrict(fmpz_mat_t res, const fmpz_mat_t mat) - slong sp2gz_nb_fundamental(slong g) - void sp2gz_fundamental(fmpz_mat_t mat, slong j) - int sp2gz_is_correct(const fmpz_mat_t mat) - int sp2gz_is_j(const fmpz_mat_t mat) - int sp2gz_is_block_diag(const fmpz_mat_t mat) - int sp2gz_is_trig(const fmpz_mat_t mat) - int sp2gz_is_embedded(fmpz_mat_t res, const fmpz_mat_t mat) - void sp2gz_inv(fmpz_mat_t inv, const fmpz_mat_t mat) - fmpz_mat_struct * sp2gz_decompose(slong * nb, const fmpz_mat_t mat) - void sp2gz_randtest(fmpz_mat_t mat, flint_rand_t state, slong bits) - void acb_siegel_cocycle(acb_mat_t c, const fmpz_mat_t mat, const acb_mat_t tau, slong prec) - void acb_siegel_transform_cocycle_inv(acb_mat_t w, acb_mat_t c, acb_mat_t cinv, const fmpz_mat_t mat, const acb_mat_t tau, slong prec) - void acb_siegel_transform(acb_mat_t w, const fmpz_mat_t mat, const acb_mat_t tau, slong prec) - void acb_siegel_cho_yinv(arb_mat_t cho, arb_mat_t yinv, const acb_mat_t tau, slong prec) - void acb_siegel_reduce(fmpz_mat_t mat, const acb_mat_t tau, slong prec) - int acb_siegel_is_reduced(const acb_mat_t tau, slong tol_exp, slong prec) - slong acb_siegel_kappa(acb_t sqrtdet, const fmpz_mat_t mat, const acb_mat_t tau, int sqr, slong prec) - slong acb_siegel_kappa2(const fmpz_mat_t mat) - void acb_siegel_randtest(acb_mat_t tau, flint_rand_t state, slong prec, slong mag_bits) - void acb_siegel_randtest_reduced(acb_mat_t tau, flint_rand_t state, slong prec, slong mag_bits) - void acb_siegel_randtest_compact(acb_mat_t tau, flint_rand_t state, int exact, slong prec) - void acb_siegel_randtest_vec(acb_ptr z, flint_rand_t state, slong g, slong prec) - void acb_siegel_randtest_vec_reduced(acb_ptr zs, flint_rand_t state, slong nb, const acb_mat_t tau, int exact, slong prec) - int acb_theta_char_bit(ulong ch, slong j, slong n) - void acb_theta_char_get_arb(arb_ptr v, ulong a, slong g) - void acb_theta_char_get_acb(acb_ptr v, ulong a, slong g) - slong acb_theta_char_dot(ulong a, ulong b, slong g) - slong acb_theta_char_dot_slong(ulong a, const slong * n, slong g) - int acb_theta_char_is_even(ulong ab, slong g) - void acb_theta_char_table(ulong * ch, slong * e, const fmpz_mat_t mat, ulong ab, int all) - void acb_theta_char_shuffle(acb_ptr res, const fmpz_mat_t mat, acb_srcptr th, int sqr, slong prec) - slong acb_theta_jet_nb(slong ord, slong g) - slong acb_theta_jet_total_order(const slong * tup, slong g) - void acb_theta_jet_tuples(slong * tups, slong ord, slong g) - slong acb_theta_jet_index(const slong * tup, slong g) - void acb_theta_jet_mul(acb_ptr res, acb_srcptr v1, acb_srcptr v2, slong ord, slong g, slong prec) - void acb_theta_jet_compose(acb_ptr res, acb_srcptr v, const acb_mat_t N, slong ord, slong prec) - void acb_theta_jet_exp_pi_i(acb_ptr res, arb_srcptr a, slong ord, slong g, slong prec) - void acb_theta_jet_exp_qf(acb_ptr res, acb_srcptr z, const acb_mat_t N, slong ord, slong prec) - void acb_theta_eld_init(acb_theta_eld_t E, slong d, slong g) - void acb_theta_eld_clear(acb_theta_eld_t E) - int acb_theta_eld_set(acb_theta_eld_t E, const arb_mat_t C, const arf_t R2, arb_srcptr v) - slong acb_theta_eld_nb_pts(acb_theta_eld_t E) - void acb_theta_eld_points(slong * pts, const acb_theta_eld_t E) - slong acb_theta_eld_box(const acb_theta_eld_t E, slong j) - slong acb_theta_eld_nb_border(acb_theta_eld_t E) - void acb_theta_eld_border(slong * pts, const acb_theta_eld_t E) - int acb_theta_eld_contains(const acb_theta_eld_t E, slong * pt) - void acb_theta_eld_print(const acb_theta_eld_t E) - void acb_theta_eld_distances(arb_ptr ds, acb_srcptr zs, slong nb, const acb_mat_t tau, slong prec) - void acb_theta_sum_radius(arf_t R2, arf_t eps, const arb_mat_t cho, slong ord, slong prec) - void acb_theta_sum_jet_radius(arf_t R2, arf_t eps, const arb_mat_t cho, arb_srcptr v, slong ord, slong prec) - void acb_theta_sum_term(acb_t res, acb_srcptr z, const acb_mat_t tau, slong * tup, slong * n, slong prec) - slong acb_theta_sum_addprec(const arb_t d) - # void acb_theta_ctx_tau_init(acb_theta_ctx_tau_t ctx, int allow_shift, slong g) - # void acb_theta_ctx_tau_clear(acb_theta_ctx_tau_t ctx) - # void acb_theta_ctx_z_init(acb_theta_ctx_z_t ctx, slong g) - # void acb_theta_ctx_z_clear(acb_theta_ctx_z_t ctx) - # acb_theta_ctx_z_struct * acb_theta_ctx_z_vec_init(slong nb, slong g) - # void acb_theta_ctx_z_vec_clear(acb_theta_ctx_z_struct * vec, slong nb) - void acb_theta_ctx_exp_inv(acb_t exp_inv, const acb_t exp, const acb_t x, int is_real, slong prec) - void acb_theta_ctx_sqr_inv(acb_t sqr_inv, const acb_t inv, const acb_t sqr, int is_real, slong prec) - # void acb_theta_ctx_tau_set(acb_theta_ctx_tau_t ctx, const acb_mat_t tau, slong prec) - # void acb_theta_ctx_tau_dupl(acb_theta_ctx_tau_t ctx, slong prec) - # int acb_theta_ctx_tau_overlaps(const acb_theta_ctx_tau_t ctx1, const acb_theta_ctx_tau_t ctx2) - # void acb_theta_ctx_z_set(acb_theta_ctx_z_t ctx, acb_srcptr z, const acb_theta_ctx_tau_t ctx_tau, slong prec) - # void acb_theta_ctx_z_dupl(acb_theta_ctx_z_t ctx, slong prec) - # void acb_theta_ctx_z_add_real(acb_theta_ctx_z_t res, const acb_theta_ctx_z_t ctx, const acb_theta_ctx_z_t ctx_real, slong prec) - # void acb_theta_ctx_z_common_v(arb_ptr v, const acb_theta_ctx_z_struct * vec, slong nb, slong prec) - # int acb_theta_ctx_z_overlaps(const acb_theta_ctx_z_t ctx1, const acb_theta_ctx_z_t ctx2) - void acb_theta_sum_sqr_pow(acb_ptr * sqr_pow, const acb_mat_t exp_tau, const acb_theta_eld_t E, slong prec) - # void acb_theta_sum_work(acb_ptr th, slong len, acb_srcptr exp_z, acb_srcptr exp_z_inv, const acb_mat_t exp_tau, const acb_mat_t exp_tau_inv, const acb_ptr * sqr_pow, const acb_theta_eld_t E, slong ord, slong prec, acb_theta_sum_worker_t worker) - # void acb_theta_sum(acb_ptr th, const acb_theta_ctx_z_struct * vec, slong nb, const acb_theta_ctx_tau_t ctx_tau, arb_srcptr distances, int all_a, int all_b, int tilde, slong prec) - # void acb_theta_sum_jet(acb_ptr th, const acb_theta_ctx_z_struct * vec, slong nb, const acb_theta_ctx_tau_t ctx_tau, slong ord, int all_a, int all_b, slong prec) - void acb_theta_agm_sqrt(acb_ptr res, acb_srcptr a, acb_srcptr roots, slong nb, slong prec) - void acb_theta_agm_mul(acb_ptr res, acb_srcptr a1, acb_srcptr a2, slong g, int all, slong prec) - void acb_theta_agm_mul_tight(acb_ptr res, acb_srcptr a0, acb_srcptr a, arb_srcptr d0, arb_srcptr d, slong g, int all, slong prec) - int acb_theta_ql_nb_steps(slong * pattern, const acb_mat_t tau, int cst, slong prec) - int acb_theta_ql_lower_dim(acb_ptr * new_zs, acb_ptr * cofactors, slong ** pts, slong * nb, arf_t err, slong * fullprec, acb_srcptr z, const acb_mat_t tau, arb_srcptr distances, slong s, ulong a, slong prec) - void acb_theta_ql_recombine(acb_ptr th, acb_srcptr th0, acb_srcptr cofactors, const slong * pts, slong nb, const arf_t err, slong fullprec, slong s, ulong a, int all, slong g, slong prec) - int acb_theta_ql_setup(acb_ptr rts, acb_ptr rts_all, acb_ptr t, slong * guard, slong * easy_steps, acb_srcptr zs, slong nb, const acb_mat_t tau, arb_srcptr distances, slong nb_steps, int all, slong prec) - void acb_theta_ql_exact(acb_ptr th, acb_srcptr zs, slong nb, const acb_mat_t tau, const slong * pattern, int all, int shifted_prec, slong prec) - void acb_theta_ql_local_bound(arb_t c, arb_t rho, acb_srcptr z, const acb_mat_t tau, slong ord) - void acb_theta_ql_jet_error(arb_ptr err, acb_srcptr z, const acb_mat_t tau, acb_srcptr dth, slong ord, slong prec) - void acb_theta_ql_jet_fd(acb_ptr th, acb_srcptr zs, slong nb, const acb_mat_t tau, slong ord, int all, slong prec) - void acb_theta_ql_jet(acb_ptr th, acb_srcptr zs, slong nb, const acb_mat_t tau, slong ord, int all, slong prec) - void acb_theta_jet_notransform(acb_ptr th, acb_srcptr zs, slong nb, const acb_mat_t tau, slong ord, ulong ab, int all, int sqr, slong prec) - int acb_theta_reduce_tau(acb_ptr new_zs, acb_mat_t new_tau, fmpz_mat_t mat, acb_mat_t N, acb_mat_t ct, acb_ptr exps, acb_srcptr zs, slong nb, const acb_mat_t tau, slong prec) - int acb_theta_reduce_z(acb_ptr new_zs, arb_ptr rs, acb_ptr cs, acb_srcptr zs, slong nb, const acb_mat_t tau, slong prec) - void acb_theta_g2_detk_symj(acb_poly_t res, const acb_mat_t m, const acb_poly_t f, slong k, slong j, slong prec) - void acb_theta_g2_transvectant(acb_poly_t res, const acb_poly_t g, const acb_poly_t h, slong m, slong n, slong k, int lead, slong prec) - slong acb_theta_g2_character(const fmpz_mat_t mat) - void acb_theta_g2_even_weight(acb_t psi4, acb_t psi6, acb_t chi10, acb_t chi12, acb_srcptr th2, slong prec) - void acb_theta_g2_chi5(acb_t res, acb_srcptr th, slong prec) - void acb_theta_g2_chi35(acb_t res, acb_srcptr th, slong prec) - void acb_theta_g2_chi3_6(acb_poly_t res, acb_srcptr dth, slong prec) - void acb_theta_g2_sextic_chi5(acb_poly_t res, acb_t chi5, const acb_mat_t tau, slong prec) - void acb_theta_g2_covariants(acb_poly_struct * res, const acb_poly_t f, int lead, slong prec) diff --git a/src/flint/flintlib/functions/arb.pxd b/src/flint/flintlib/functions/arb.pxd deleted file mode 100644 index c2003820..00000000 --- a/src/flint/flintlib/functions/arb.pxd +++ /dev/null @@ -1,380 +0,0 @@ -from flint.flintlib.types.arb cimport arb_ptr, arb_srcptr, arb_t, mag_srcptr, mag_t -from flint.flintlib.types.arf cimport arf_rnd_t, arf_srcptr, arf_t -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t - -# unknown type FILE -# unknown type mpfr_rnd_t -# unknown type mpfr_t - -# .. macro:: arb_midref(x) -# .. macro:: arb_radref(x) -# .. macro:: ARB_LOG_PRIME_CACHE_NUM -# .. macro:: ARB_LOG_REDUCTION_DEFAULT_MAX_PREC -# .. macro:: ARB_ATAN_GAUSS_PRIME_CACHE_NUM - -cdef extern from "flint/arb.h": - void arb_init(arb_t x) - void arb_clear(arb_t x) - arb_ptr _arb_vec_init(slong n) - void _arb_vec_clear(arb_ptr v, slong n) - void arb_swap(arb_t x, arb_t y) - slong arb_allocated_bytes(const arb_t x) - slong _arb_vec_allocated_bytes(arb_srcptr vec, slong len) - double _arb_vec_estimate_allocated_bytes(slong len, slong prec) - void arb_set(arb_t y, const arb_t x) - void arb_set_arf(arb_t y, const arf_t x) - void arb_set_si(arb_t y, slong x) - void arb_set_ui(arb_t y, ulong x) - void arb_set_fmpz(arb_t y, const fmpz_t x) - void arb_set_d(arb_t y, double x) - void arb_set_fmpz_2exp(arb_t y, const fmpz_t x, const fmpz_t e) - void arb_set_round(arb_t y, const arb_t x, slong prec) - void arb_set_round_fmpz(arb_t y, const fmpz_t x, slong prec) - void arb_set_round_fmpz_2exp(arb_t y, const fmpz_t x, const fmpz_t e, slong prec) - void arb_set_fmpq(arb_t y, const fmpq_t x, slong prec) - int arb_set_str(arb_t res, const char * inp, slong prec) - char * arb_get_str(const arb_t x, slong n, ulong flags) - void arb_zero(arb_t x) - void arb_one(arb_t f) - void arb_pos_inf(arb_t x) - void arb_neg_inf(arb_t x) - void arb_zero_pm_inf(arb_t x) - void arb_indeterminate(arb_t x) - void arb_zero_pm_one(arb_t x) - void arb_unit_interval(arb_t x) - void arb_print(const arb_t x) - # void arb_fprint(FILE * file, const arb_t x) - void arb_printd(const arb_t x, slong digits) - # void arb_fprintd(FILE * file, const arb_t x, slong digits) - void arb_printn(const arb_t x, slong digits, ulong flags) - # void arb_fprintn(FILE * file, const arb_t x, slong digits, ulong flags) - char * arb_dump_str(const arb_t x) - int arb_load_str(arb_t x, const char * str) - # int arb_dump_file(FILE * stream, const arb_t x) - # int arb_load_file(arb_t x, FILE * stream) - void arb_randtest(arb_t x, flint_rand_t state, slong prec, slong mag_bits) - void arb_randtest_exact(arb_t x, flint_rand_t state, slong prec, slong mag_bits) - void arb_randtest_precise(arb_t x, flint_rand_t state, slong prec, slong mag_bits) - void arb_randtest_positive(arb_t x, flint_rand_t state, slong prec, slong mag_bits) - void arb_randtest_wide(arb_t x, flint_rand_t state, slong prec, slong mag_bits) - void arb_randtest_special(arb_t x, flint_rand_t state, slong prec, slong mag_bits) - void arb_get_rand_fmpq(fmpq_t q, flint_rand_t state, const arb_t x, slong bits) - void arb_urandom(arb_t x, flint_rand_t state, slong prec) - void arb_get_mid_arb(arb_t m, const arb_t x) - void arb_get_rad_arb(arb_t r, const arb_t x) - void arb_add_error_arf(arb_t x, const arf_t err) - void arb_add_error_mag(arb_t x, const mag_t err) - void arb_add_error(arb_t x, const arb_t err) - void arb_add_error_2exp_si(arb_t x, slong e) - void arb_add_error_2exp_fmpz(arb_t x, const fmpz_t e) - void arb_union(arb_t z, const arb_t x, const arb_t y, slong prec) - int arb_intersection(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_nonnegative_part(arb_t res, const arb_t x) - void arb_get_abs_ubound_arf(arf_t u, const arb_t x, slong prec) - void arb_get_abs_lbound_arf(arf_t u, const arb_t x, slong prec) - void arb_get_ubound_arf(arf_t u, const arb_t x, slong prec) - void arb_get_lbound_arf(arf_t u, const arb_t x, slong prec) - void arb_get_mag(mag_t z, const arb_t x) - void arb_get_mag_lower(mag_t z, const arb_t x) - void arb_get_mag_lower_nonnegative(mag_t z, const arb_t x) - void arb_get_interval_fmpz_2exp(fmpz_t a, fmpz_t b, fmpz_t exp, const arb_t x) - void arb_set_interval_mag(arb_t x, const mag_t a, const mag_t b, slong prec) - void arb_set_interval_arf(arb_t x, const arf_t a, const arf_t b, slong prec) - # void arb_set_interval_mpfr(arb_t x, const mpfr_t a, const mpfr_t b, slong prec) - void arb_set_interval_neg_pos_mag(arb_t x, const mag_t a, const mag_t b, slong prec) - void arb_get_interval_arf(arf_t a, arf_t b, const arb_t x, slong prec) - # void arb_get_interval_mpfr(mpfr_t a, mpfr_t b, const arb_t x) - slong arb_rel_error_bits(const arb_t x) - slong arb_rel_accuracy_bits(const arb_t x) - slong arb_rel_one_accuracy_bits(const arb_t x) - slong arb_bits(const arb_t x) - void arb_trim(arb_t y, const arb_t x) - int arb_get_unique_fmpz(fmpz_t z, const arb_t x) - void arb_floor(arb_t y, const arb_t x, slong prec) - void arb_ceil(arb_t y, const arb_t x, slong prec) - void arb_trunc(arb_t y, const arb_t x, slong prec) - void arb_nint(arb_t y, const arb_t x, slong prec) - void arb_get_fmpz_mid_rad_10exp(fmpz_t mid, fmpz_t rad, fmpz_t exp, const arb_t x, slong n) - int arb_can_round_arf(const arb_t x, slong prec, arf_rnd_t rnd) - # int arb_can_round_mpfr(const arb_t x, slong prec, mpfr_rnd_t rnd) - int arb_is_zero(const arb_t x) - int arb_is_nonzero(const arb_t x) - int arb_is_one(const arb_t f) - int arb_is_finite(const arb_t x) - int arb_is_exact(const arb_t x) - int arb_is_int(const arb_t x) - int arb_is_int_2exp_si(const arb_t x, slong e) - int arb_equal(const arb_t x, const arb_t y) - int arb_equal_si(const arb_t x, slong y) - int arb_is_positive(const arb_t x) - int arb_is_nonnegative(const arb_t x) - int arb_is_negative(const arb_t x) - int arb_is_nonpositive(const arb_t x) - int arb_overlaps(const arb_t x, const arb_t y) - int arb_contains_arf(const arb_t x, const arf_t y) - int arb_contains_fmpq(const arb_t x, const fmpq_t y) - int arb_contains_fmpz(const arb_t x, const fmpz_t y) - int arb_contains_si(const arb_t x, slong y) - # int arb_contains_mpfr(const arb_t x, const mpfr_t y) - int arb_contains(const arb_t x, const arb_t y) - int arb_contains_int(const arb_t x) - int arb_contains_zero(const arb_t x) - int arb_contains_negative(const arb_t x) - int arb_contains_nonpositive(const arb_t x) - int arb_contains_positive(const arb_t x) - int arb_contains_nonnegative(const arb_t x) - int arb_contains_interior(const arb_t x, const arb_t y) - int arb_eq(const arb_t x, const arb_t y) - int arb_ne(const arb_t x, const arb_t y) - int arb_lt(const arb_t x, const arb_t y) - int arb_le(const arb_t x, const arb_t y) - int arb_gt(const arb_t x, const arb_t y) - int arb_ge(const arb_t x, const arb_t y) - void arb_neg(arb_t y, const arb_t x) - void arb_neg_round(arb_t y, const arb_t x, slong prec) - void arb_abs(arb_t y, const arb_t x) - void arb_nonnegative_abs(arb_t y, const arb_t x) - void arb_sgn(arb_t y, const arb_t x) - int arb_sgn_nonzero(const arb_t x) - void arb_min(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_max(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_minmax(arb_t z1, arb_t z2, const arb_t x, const arb_t y, slong prec) - void arb_add(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_add_arf(arb_t z, const arb_t x, const arf_t y, slong prec) - void arb_add_ui(arb_t z, const arb_t x, ulong y, slong prec) - void arb_add_si(arb_t z, const arb_t x, slong y, slong prec) - void arb_add_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec) - void arb_add_fmpz_2exp(arb_t z, const arb_t x, const fmpz_t m, const fmpz_t e, slong prec) - void arb_sub(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_sub_arf(arb_t z, const arb_t x, const arf_t y, slong prec) - void arb_sub_ui(arb_t z, const arb_t x, ulong y, slong prec) - void arb_sub_si(arb_t z, const arb_t x, slong y, slong prec) - void arb_sub_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec) - void arb_mul(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_mul_arf(arb_t z, const arb_t x, const arf_t y, slong prec) - void arb_mul_si(arb_t z, const arb_t x, slong y, slong prec) - void arb_mul_ui(arb_t z, const arb_t x, ulong y, slong prec) - void arb_mul_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec) - void arb_mul_2exp_si(arb_t y, const arb_t x, slong e) - void arb_mul_2exp_fmpz(arb_t y, const arb_t x, const fmpz_t e) - void arb_addmul(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_addmul_arf(arb_t z, const arb_t x, const arf_t y, slong prec) - void arb_addmul_si(arb_t z, const arb_t x, slong y, slong prec) - void arb_addmul_ui(arb_t z, const arb_t x, ulong y, slong prec) - void arb_addmul_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec) - void arb_submul(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_submul_arf(arb_t z, const arb_t x, const arf_t y, slong prec) - void arb_submul_si(arb_t z, const arb_t x, slong y, slong prec) - void arb_submul_ui(arb_t z, const arb_t x, ulong y, slong prec) - void arb_submul_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec) - void arb_fma(arb_t res, const arb_t x, const arb_t y, const arb_t z, slong prec) - void arb_fma_arf(arb_t res, const arb_t x, const arf_t y, const arb_t z, slong prec) - void arb_fma_si(arb_t res, const arb_t x, slong y, const arb_t z, slong prec) - void arb_fma_ui(arb_t res, const arb_t x, ulong y, const arb_t z, slong prec) - void arb_fma_fmpz(arb_t res, const arb_t x, const fmpz_t y, const arb_t z, slong prec) - void arb_inv(arb_t z, const arb_t x, slong prec) - void arb_div(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_div_arf(arb_t z, const arb_t x, const arf_t y, slong prec) - void arb_div_si(arb_t z, const arb_t x, slong y, slong prec) - void arb_div_ui(arb_t z, const arb_t x, ulong y, slong prec) - void arb_div_fmpz(arb_t z, const arb_t x, const fmpz_t y, slong prec) - void arb_fmpz_div_fmpz(arb_t z, const fmpz_t x, const fmpz_t y, slong prec) - void arb_ui_div(arb_t z, ulong x, const arb_t y, slong prec) - void arb_div_2expm1_ui(arb_t z, const arb_t x, ulong n, slong prec) - void arb_dot_precise(arb_t res, const arb_t s, int subtract, arb_srcptr x, slong xstep, arb_srcptr y, slong ystep, slong len, slong prec) - void arb_dot_simple(arb_t res, const arb_t s, int subtract, arb_srcptr x, slong xstep, arb_srcptr y, slong ystep, slong len, slong prec) - void arb_dot(arb_t res, const arb_t s, int subtract, arb_srcptr x, slong xstep, arb_srcptr y, slong ystep, slong len, slong prec) - void arb_approx_dot(arb_t res, const arb_t s, int subtract, arb_srcptr x, slong xstep, arb_srcptr y, slong ystep, slong len, slong prec) - void arb_dot_ui(arb_t res, const arb_t initial, int subtract, arb_srcptr x, slong xstep, const ulong * y, slong ystep, slong len, slong prec) - void arb_dot_si(arb_t res, const arb_t initial, int subtract, arb_srcptr x, slong xstep, const slong * y, slong ystep, slong len, slong prec) - void arb_dot_uiui(arb_t res, const arb_t initial, int subtract, arb_srcptr x, slong xstep, const ulong * y, slong ystep, slong len, slong prec) - void arb_dot_siui(arb_t res, const arb_t initial, int subtract, arb_srcptr x, slong xstep, const ulong * y, slong ystep, slong len, slong prec) - void arb_dot_fmpz(arb_t res, const arb_t initial, int subtract, arb_srcptr x, slong xstep, const fmpz_struct * y, slong ystep, slong len, slong prec) - void arb_sqrt(arb_t z, const arb_t x, slong prec) - void arb_sqrt_arf(arb_t z, const arf_t x, slong prec) - void arb_sqrt_fmpz(arb_t z, const fmpz_t x, slong prec) - void arb_sqrt_ui(arb_t z, ulong x, slong prec) - void arb_sqrtpos(arb_t z, const arb_t x, slong prec) - void arb_hypot(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_rsqrt(arb_t z, const arb_t x, slong prec) - void arb_rsqrt_ui(arb_t z, ulong x, slong prec) - void arb_sqrt1pm1(arb_t z, const arb_t x, slong prec) - void arb_root_ui(arb_t z, const arb_t x, ulong k, slong prec) - void arb_root(arb_t z, const arb_t x, ulong k, slong prec) - void arb_sqr(arb_t y, const arb_t x, slong prec) - void arb_pow_fmpz_binexp(arb_t y, const arb_t b, const fmpz_t e, slong prec) - void arb_pow_fmpz(arb_t y, const arb_t b, const fmpz_t e, slong prec) - void arb_pow_ui(arb_t y, const arb_t b, ulong e, slong prec) - void arb_ui_pow_ui(arb_t y, ulong b, ulong e, slong prec) - void arb_si_pow_ui(arb_t y, slong b, ulong e, slong prec) - void arb_pow_fmpq(arb_t y, const arb_t x, const fmpq_t a, slong prec) - void arb_pow(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_log_ui(arb_t z, ulong x, slong prec) - void arb_log_fmpz(arb_t z, const fmpz_t x, slong prec) - void arb_log_arf(arb_t z, const arf_t x, slong prec) - void arb_log(arb_t z, const arb_t x, slong prec) - void arb_log_ui_from_prev(arb_t log_k1, ulong k1, arb_t log_k0, ulong k0, slong prec) - void arb_log1p(arb_t z, const arb_t x, slong prec) - void arb_log_base_ui(arb_t res, const arb_t x, ulong b, slong prec) - void arb_log_hypot(arb_t res, const arb_t x, const arb_t y, slong prec) - void arb_exp(arb_t z, const arb_t x, slong prec) - void arb_expm1(arb_t z, const arb_t x, slong prec) - void arb_exp_invexp(arb_t z, arb_t w, const arb_t x, slong prec) - void arb_sin(arb_t s, const arb_t x, slong prec) - void arb_cos(arb_t c, const arb_t x, slong prec) - void arb_sin_cos(arb_t s, arb_t c, const arb_t x, slong prec) - void arb_sin_pi(arb_t s, const arb_t x, slong prec) - void arb_cos_pi(arb_t c, const arb_t x, slong prec) - void arb_sin_cos_pi(arb_t s, arb_t c, const arb_t x, slong prec) - void arb_tan(arb_t y, const arb_t x, slong prec) - void arb_cot(arb_t y, const arb_t x, slong prec) - void arb_sin_cos_pi_fmpq(arb_t s, arb_t c, const fmpq_t x, slong prec) - void arb_sin_pi_fmpq(arb_t s, const fmpq_t x, slong prec) - void arb_cos_pi_fmpq(arb_t c, const fmpq_t x, slong prec) - void arb_tan_pi(arb_t y, const arb_t x, slong prec) - void arb_cot_pi(arb_t y, const arb_t x, slong prec) - void arb_sec(arb_t res, const arb_t x, slong prec) - void arb_csc(arb_t res, const arb_t x, slong prec) - void arb_csc_pi(arb_t res, const arb_t x, slong prec) - void arb_sinc(arb_t z, const arb_t x, slong prec) - void arb_sinc_pi(arb_t z, const arb_t x, slong prec) - void arb_atan_arf(arb_t z, const arf_t x, slong prec) - void arb_atan(arb_t z, const arb_t x, slong prec) - void arb_atan2(arb_t z, const arb_t b, const arb_t a, slong prec) - void arb_asin(arb_t z, const arb_t x, slong prec) - void arb_acos(arb_t z, const arb_t x, slong prec) - void arb_sinh(arb_t s, const arb_t x, slong prec) - void arb_cosh(arb_t c, const arb_t x, slong prec) - void arb_sinh_cosh(arb_t s, arb_t c, const arb_t x, slong prec) - void arb_tanh(arb_t y, const arb_t x, slong prec) - void arb_coth(arb_t y, const arb_t x, slong prec) - void arb_sech(arb_t res, const arb_t x, slong prec) - void arb_csch(arb_t res, const arb_t x, slong prec) - void arb_atanh(arb_t z, const arb_t x, slong prec) - void arb_asinh(arb_t z, const arb_t x, slong prec) - void arb_acosh(arb_t z, const arb_t x, slong prec) - void arb_const_pi(arb_t z, slong prec) - void arb_const_sqrt_pi(arb_t z, slong prec) - void arb_const_log_sqrt2pi(arb_t z, slong prec) - void arb_const_log2(arb_t z, slong prec) - void arb_const_log10(arb_t z, slong prec) - void arb_const_euler(arb_t z, slong prec) - void arb_const_catalan(arb_t z, slong prec) - void arb_const_e(arb_t z, slong prec) - void arb_const_khinchin(arb_t z, slong prec) - void arb_const_glaisher(arb_t z, slong prec) - void arb_const_apery(arb_t z, slong prec) - void arb_const_reciprocal_fibonacci(arb_t z, slong prec) - void arb_lambertw(arb_t res, const arb_t x, int flags, slong prec) - void arb_rising_ui(arb_t z, const arb_t x, ulong n, slong prec) - void arb_rising(arb_t z, const arb_t x, const arb_t n, slong prec) - void arb_rising_fmpq_ui(arb_t z, const fmpq_t x, ulong n, slong prec) - void arb_rising2_ui(arb_t u, arb_t v, const arb_t x, ulong n, slong prec) - void arb_fac_ui(arb_t z, ulong n, slong prec) - void arb_doublefac_ui(arb_t z, ulong n, slong prec) - void arb_bin_ui(arb_t z, const arb_t n, ulong k, slong prec) - void arb_bin_uiui(arb_t z, ulong n, ulong k, slong prec) - void arb_gamma(arb_t z, const arb_t x, slong prec) - void arb_gamma_fmpq(arb_t z, const fmpq_t x, slong prec) - void arb_gamma_fmpz(arb_t z, const fmpz_t x, slong prec) - void arb_lgamma(arb_t z, const arb_t x, slong prec) - void arb_rgamma(arb_t z, const arb_t x, slong prec) - void arb_digamma(arb_t y, const arb_t x, slong prec) - void arb_zeta_ui_vec_borwein(arb_ptr z, ulong start, slong num, ulong step, slong prec) - void arb_zeta_ui_asymp(arb_t x, ulong s, slong prec) - void arb_zeta_ui_euler_product(arb_t z, ulong s, slong prec) - void arb_zeta_ui_bernoulli(arb_t x, ulong s, slong prec) - void arb_zeta_ui_borwein_bsplit(arb_t x, ulong s, slong prec) - void arb_zeta_ui_vec(arb_ptr x, ulong start, slong num, slong prec) - void arb_zeta_ui_vec_even(arb_ptr x, ulong start, slong num, slong prec) - void arb_zeta_ui_vec_odd(arb_ptr x, ulong start, slong num, slong prec) - void arb_zeta_ui(arb_t x, ulong s, slong prec) - void arb_zeta(arb_t z, const arb_t s, slong prec) - void arb_hurwitz_zeta(arb_t z, const arb_t s, const arb_t a, slong prec) - void arb_bernoulli_ui(arb_t b, ulong n, slong prec) - void arb_bernoulli_fmpz(arb_t b, const fmpz_t n, slong prec) - void arb_bernoulli_ui_zeta(arb_t b, ulong n, slong prec) - void arb_bernoulli_poly_ui(arb_t res, ulong n, const arb_t x, slong prec) - void arb_power_sum_vec(arb_ptr res, const arb_t a, const arb_t b, slong len, slong prec) - void arb_polylog(arb_t w, const arb_t s, const arb_t z, slong prec) - void arb_polylog_si(arb_t w, slong s, const arb_t z, slong prec) - void arb_fib_fmpz(arb_t z, const fmpz_t n, slong prec) - void arb_fib_ui(arb_t z, ulong n, slong prec) - void arb_agm(arb_t z, const arb_t x, const arb_t y, slong prec) - void arb_chebyshev_t_ui(arb_t a, ulong n, const arb_t x, slong prec) - void arb_chebyshev_u_ui(arb_t a, ulong n, const arb_t x, slong prec) - void arb_chebyshev_t2_ui(arb_t a, arb_t b, ulong n, const arb_t x, slong prec) - void arb_chebyshev_u2_ui(arb_t a, arb_t b, ulong n, const arb_t x, slong prec) - void arb_bell_sum_bsplit(arb_t res, const fmpz_t n, const fmpz_t a, const fmpz_t b, const fmpz_t mmag, slong prec) - void arb_bell_sum_taylor(arb_t res, const fmpz_t n, const fmpz_t a, const fmpz_t b, const fmpz_t mmag, slong prec) - void arb_bell_fmpz(arb_t res, const fmpz_t n, slong prec) - void arb_bell_ui(arb_t res, ulong n, slong prec) - void arb_euler_number_fmpz(arb_t res, const fmpz_t n, slong prec) - void arb_euler_number_ui(arb_t res, ulong n, slong prec) - void arb_fmpz_euler_number_ui_multi_mod(fmpz_t res, ulong n, double alpha) - void arb_fmpz_euler_number_ui(fmpz_t res, ulong n) - void arb_partitions_fmpz(arb_t res, const fmpz_t n, slong prec) - void arb_partitions_ui(arb_t res, ulong n, slong prec) - void arb_primorial_nth_ui(arb_t res, ulong n, slong prec) - void arb_primorial_ui(arb_t res, ulong n, slong prec) - void _arb_atan_taylor_naive(nn_ptr y, ulong * error, nn_srcptr x, slong xn, ulong N, int alternating) - void _arb_atan_taylor_rs(nn_ptr y, ulong * error, nn_srcptr x, slong xn, ulong N, int alternating) - void _arb_exp_taylor_naive(nn_ptr y, ulong * error, nn_srcptr x, slong xn, ulong N) - void _arb_exp_taylor_rs(nn_ptr y, ulong * error, nn_srcptr x, slong xn, ulong N) - void _arb_sin_cos_taylor_naive(nn_ptr ysin, nn_ptr ycos, ulong * error, nn_srcptr x, slong xn, ulong N) - void _arb_sin_cos_taylor_rs(nn_ptr ysin, nn_ptr ycos, ulong * error, nn_srcptr x, slong xn, ulong N, int sinonly, int alternating) - int _arb_get_mpn_fixed_mod_log2(nn_ptr w, fmpz_t q, ulong * error, const arf_t x, slong wn) - int _arb_get_mpn_fixed_mod_pi4(nn_ptr w, fmpz_t q, int * octant, ulong * error, const arf_t x, slong wn) - slong _arb_exp_taylor_bound(slong mag, slong prec) - void arb_exp_arf_bb(arb_t z, const arf_t x, slong prec, int m1) - void _arb_exp_sum_bs_simple(fmpz_t T, fmpz_t Q, flint_bitcnt_t * Qexp, const fmpz_t x, flint_bitcnt_t r, slong N) - void _arb_exp_sum_bs_powtab(fmpz_t T, fmpz_t Q, flint_bitcnt_t * Qexp, const fmpz_t x, flint_bitcnt_t r, slong N) - void arb_exp_arf_rs_generic(arb_t res, const arf_t x, slong prec, int minus_one) - void _arb_atan_sum_bs_simple(fmpz_t T, fmpz_t Q, flint_bitcnt_t * Qexp, const fmpz_t x, flint_bitcnt_t r, slong N) - void _arb_atan_sum_bs_powtab(fmpz_t T, fmpz_t Q, flint_bitcnt_t * Qexp, const fmpz_t x, flint_bitcnt_t r, slong N) - void arb_atan_arf_bb(arb_t z, const arf_t x, slong prec) - void arb_atan_frac_bsplit(arb_t s, const fmpz_t p, const fmpz_t q, int hyperbolic, slong prec) - void arb_sin_cos_arf_generic(arb_t s, arb_t c, const arf_t x, slong prec) - void arb_sin_cos_arf_bb(arb_t s, arb_t c, const arf_t x, slong prec) - void arb_sin_cos_wide(arb_t s, arb_t c, const arb_t x, slong prec) - void arb_sin_cos_generic(arb_t s, arb_t c, const arb_t x, slong prec) - void arb_log_primes_vec_bsplit(arb_ptr res, slong n, slong prec) - void _arb_log_p_ensure_cached(slong prec) - void arb_exp_arf_log_reduction(arb_t res, const arf_t x, slong prec, int minus_one) - void arb_exp_arf_generic(arb_t z, const arf_t x, slong prec, int minus_one) - void arb_exp_arf(arb_t z, const arf_t x, slong prec, int minus_one, slong maglim) - void arb_log_newton(arb_t res, const arb_t x, slong prec) - void arb_log_arf_newton(arb_t res, const arf_t x, slong prec) - void arb_atan_gauss_primes_vec_bsplit(arb_ptr res, slong n, slong prec) - void _arb_atan_gauss_p_ensure_cached(slong prec) - void arb_sin_cos_arf_atan_reduction(arb_t res1, arb_t res2, const arf_t x, slong prec) - void arb_atan_newton(arb_t res, const arb_t x, slong prec) - void arb_atan_arf_newton(arb_t res, const arf_t x, slong prec) - void _arb_vec_zero(arb_ptr vec, slong n) - int _arb_vec_is_zero(arb_srcptr vec, slong len) - int _arb_vec_is_finite(arb_srcptr x, slong len) - int _arb_vec_equal(arb_srcptr vec1, arb_srcptr vec2, slong len) - int _arb_vec_overlaps(arb_srcptr vec1, arb_srcptr vec2, slong len) - int _arb_vec_contains(arb_srcptr vec1, arb_srcptr vec2, slong len) - void _arb_vec_set(arb_ptr res, arb_srcptr vec, slong len) - void _arb_vec_set_round(arb_ptr res, arb_srcptr vec, slong len, slong prec) - void _arb_vec_swap(arb_ptr vec1, arb_ptr vec2, slong len) - void _arb_vec_neg(arb_ptr B, arb_srcptr A, slong n) - void _arb_vec_sub(arb_ptr C, arb_srcptr A, arb_srcptr B, slong n, slong prec) - void _arb_vec_add(arb_ptr C, arb_srcptr A, arb_srcptr B, slong n, slong prec) - void _arb_vec_scalar_mul(arb_ptr res, arb_srcptr vec, slong len, const arb_t c, slong prec) - void _arb_vec_scalar_div(arb_ptr res, arb_srcptr vec, slong len, const arb_t c, slong prec) - void _arb_vec_scalar_mul_fmpz(arb_ptr res, arb_srcptr vec, slong len, const fmpz_t c, slong prec) - void _arb_vec_scalar_mul_2exp_si(arb_ptr res, arb_srcptr src, slong len, slong c) - void _arb_vec_scalar_addmul(arb_ptr res, arb_srcptr vec, slong len, const arb_t c, slong prec) - void _arb_vec_get_mag(mag_t bound, arb_srcptr vec, slong len) - slong _arb_vec_bits(arb_srcptr x, slong len) - void _arb_vec_set_powers(arb_ptr xs, const arb_t x, slong len, slong prec) - void _arb_vec_add_error_arf_vec(arb_ptr res, arf_srcptr err, slong len) - void _arb_vec_add_error_mag_vec(arb_ptr res, mag_srcptr err, slong len) - void _arb_vec_indeterminate(arb_ptr vec, slong len) - void _arb_vec_trim(arb_ptr res, arb_srcptr vec, slong len) - int _arb_vec_get_unique_fmpz_vec(fmpz_struct * res, arb_srcptr vec, slong len) - void _arb_vec_printn(arb_srcptr vec, slong len, slong digits, ulong flags) - void _arb_vec_printd(arb_srcptr vec, slong len, slong ndigits) diff --git a/src/flint/flintlib/functions/arb_fmpz_poly.pxd b/src/flint/flintlib/functions/arb_fmpz_poly.pxd deleted file mode 100644 index e35204bb..00000000 --- a/src/flint/flintlib/functions/arb_fmpz_poly.pxd +++ /dev/null @@ -1,24 +0,0 @@ -from flint.flintlib.types.acb cimport acb_ptr, acb_t -from flint.flintlib.types.arb cimport arb_t -from flint.flintlib.types.flint cimport fmpz_struct, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_poly_t - - - -cdef extern from "flint/arb_fmpz_poly.h": - void _arb_fmpz_poly_evaluate_arb_horner(arb_t res, const fmpz_struct * poly, slong len, const arb_t x, slong prec) - void arb_fmpz_poly_evaluate_arb_horner(arb_t res, const fmpz_poly_t poly, const arb_t x, slong prec) - void _arb_fmpz_poly_evaluate_arb_rectangular(arb_t res, const fmpz_struct * poly, slong len, const arb_t x, slong prec) - void arb_fmpz_poly_evaluate_arb_rectangular(arb_t res, const fmpz_poly_t poly, const arb_t x, slong prec) - void _arb_fmpz_poly_evaluate_arb(arb_t res, const fmpz_struct * poly, slong len, const arb_t x, slong prec) - void arb_fmpz_poly_evaluate_arb(arb_t res, const fmpz_poly_t poly, const arb_t x, slong prec) - void _arb_fmpz_poly_evaluate_acb_horner(acb_t res, const fmpz_struct * poly, slong len, const acb_t x, slong prec) - void arb_fmpz_poly_evaluate_acb_horner(acb_t res, const fmpz_poly_t poly, const acb_t x, slong prec) - void _arb_fmpz_poly_evaluate_acb_rectangular(acb_t res, const fmpz_struct * poly, slong len, const acb_t x, slong prec) - void arb_fmpz_poly_evaluate_acb_rectangular(acb_t res, const fmpz_poly_t poly, const acb_t x, slong prec) - void _arb_fmpz_poly_evaluate_acb(acb_t res, const fmpz_struct * poly, slong len, const acb_t x, slong prec) - void arb_fmpz_poly_evaluate_acb(acb_t res, const fmpz_poly_t poly, const acb_t x, slong prec) - ulong arb_fmpz_poly_deflation(const fmpz_poly_t poly) - void arb_fmpz_poly_deflate(fmpz_poly_t res, const fmpz_poly_t poly, ulong deflation) - void arb_fmpz_poly_complex_roots(acb_ptr roots, const fmpz_poly_t poly, int flags, slong prec) - void arb_fmpz_poly_gauss_period_minpoly(fmpz_poly_t res, ulong q, ulong n) diff --git a/src/flint/flintlib/functions/arb_hypgeom.pxd b/src/flint/flintlib/functions/arb_hypgeom.pxd deleted file mode 100644 index a00c931e..00000000 --- a/src/flint/flintlib/functions/arb_hypgeom.pxd +++ /dev/null @@ -1,137 +0,0 @@ -from flint.flintlib.types.arb cimport arb_poly_t, arb_ptr, arb_srcptr, arb_t, mag_t -from flint.flintlib.types.flint cimport fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_struct, fmpq_t - - - -cdef extern from "flint/arb_hypgeom.h": - void _arb_hypgeom_rising_coeffs_1(ulong * c, ulong k, slong n) - void _arb_hypgeom_rising_coeffs_2(ulong * c, ulong k, slong n) - void _arb_hypgeom_rising_coeffs_fmpz(fmpz_struct * c, ulong k, slong n) - void arb_hypgeom_rising_ui_forward(arb_t res, const arb_t x, ulong n, slong prec) - void arb_hypgeom_rising_ui_bs(arb_t res, const arb_t x, ulong n, slong prec) - void arb_hypgeom_rising_ui_rs(arb_t res, const arb_t x, ulong n, ulong m, slong prec) - void arb_hypgeom_rising_ui_rec(arb_t res, const arb_t x, ulong n, slong prec) - void arb_hypgeom_rising_ui(arb_t res, const arb_t x, ulong n, slong prec) - void arb_hypgeom_rising(arb_t res, const arb_t x, const arb_t n, slong prec) - void arb_hypgeom_rising_ui_jet_powsum(arb_ptr res, const arb_t x, ulong n, slong len, slong prec) - void arb_hypgeom_rising_ui_jet_bs(arb_ptr res, const arb_t x, ulong n, slong len, slong prec) - void arb_hypgeom_rising_ui_jet_rs(arb_ptr res, const arb_t x, ulong n, ulong m, slong len, slong prec) - void arb_hypgeom_rising_ui_jet(arb_ptr res, const arb_t x, ulong n, slong len, slong prec) - void _arb_hypgeom_gamma_stirling_term_bounds(slong * bound, const mag_t zinv, slong N) - void arb_hypgeom_gamma_stirling_sum_horner(arb_t res, const arb_t z, slong N, slong prec) - void arb_hypgeom_gamma_stirling_sum_improved(arb_t res, const arb_t z, slong N, slong K, slong prec) - void arb_hypgeom_gamma_stirling(arb_t res, const arb_t x, int reciprocal, slong prec) - int arb_hypgeom_gamma_taylor(arb_t res, const arb_t x, int reciprocal, slong prec) - void arb_hypgeom_gamma(arb_t res, const arb_t x, slong prec) - void arb_hypgeom_gamma_fmpq(arb_t res, const fmpq_t x, slong prec) - void arb_hypgeom_gamma_fmpz(arb_t res, const fmpz_t x, slong prec) - void arb_hypgeom_rgamma(arb_t res, const arb_t x, slong prec) - void arb_hypgeom_lgamma(arb_t res, const arb_t x, slong prec) - void arb_hypgeom_central_bin_ui(arb_t res, ulong n, slong prec) - void arb_hypgeom_pfq(arb_t res, arb_srcptr a, slong p, arb_srcptr b, slong q, const arb_t z, int regularized, slong prec) - void arb_hypgeom_0f1(arb_t res, const arb_t a, const arb_t z, int regularized, slong prec) - void arb_hypgeom_m(arb_t res, const arb_t a, const arb_t b, const arb_t z, int regularized, slong prec) - void arb_hypgeom_1f1(arb_t res, const arb_t a, const arb_t b, const arb_t z, int regularized, slong prec) - void arb_hypgeom_1f1_integration(arb_t res, const arb_t a, const arb_t b, const arb_t z, int regularized, slong prec) - void arb_hypgeom_u(arb_t res, const arb_t a, const arb_t b, const arb_t z, slong prec) - void arb_hypgeom_u_integration(arb_t res, const arb_t a, const arb_t b, const arb_t z, slong prec) - void arb_hypgeom_2f1(arb_t res, const arb_t a, const arb_t b, const arb_t c, const arb_t z, int regularized, slong prec) - void arb_hypgeom_2f1_integration(arb_t res, const arb_t a, const arb_t b, const arb_t c, const arb_t z, int regularized, slong prec) - void arb_hypgeom_erf(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_erf_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_erf_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_erfc(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_erfc_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_erfc_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_erfi(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_erfi_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_erfi_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_erfinv(arb_t res, const arb_t z, slong prec) - void arb_hypgeom_erfcinv(arb_t res, const arb_t z, slong prec) - void arb_hypgeom_fresnel(arb_t res1, arb_t res2, const arb_t z, int normalized, slong prec) - void _arb_hypgeom_fresnel_series(arb_ptr res1, arb_ptr res2, arb_srcptr z, slong zlen, int normalized, slong len, slong prec) - void arb_hypgeom_fresnel_series(arb_poly_t res1, arb_poly_t res2, const arb_poly_t z, int normalized, slong len, slong prec) - void arb_hypgeom_gamma_upper(arb_t res, const arb_t s, const arb_t z, int regularized, slong prec) - void arb_hypgeom_gamma_upper_integration(arb_t res, const arb_t s, const arb_t z, int regularized, slong prec) - void _arb_hypgeom_gamma_upper_series(arb_ptr res, const arb_t s, arb_srcptr z, slong zlen, int regularized, slong n, slong prec) - void arb_hypgeom_gamma_upper_series(arb_poly_t res, const arb_t s, const arb_poly_t z, int regularized, slong n, slong prec) - void arb_hypgeom_gamma_lower(arb_t res, const arb_t s, const arb_t z, int regularized, slong prec) - void _arb_hypgeom_gamma_lower_series(arb_ptr res, const arb_t s, arb_srcptr z, slong zlen, int regularized, slong n, slong prec) - void arb_hypgeom_gamma_lower_series(arb_poly_t res, const arb_t s, const arb_poly_t z, int regularized, slong n, slong prec) - void arb_hypgeom_beta_lower(arb_t res, const arb_t a, const arb_t b, const arb_t z, int regularized, slong prec) - void _arb_hypgeom_beta_lower_series(arb_ptr res, const arb_t a, const arb_t b, arb_srcptr z, slong zlen, int regularized, slong n, slong prec) - void arb_hypgeom_beta_lower_series(arb_poly_t res, const arb_t a, const arb_t b, const arb_poly_t z, int regularized, slong n, slong prec) - void _arb_hypgeom_gamma_lower_sum_rs_1(arb_t res, ulong p, ulong q, const arb_t z, slong N, slong prec) - void _arb_hypgeom_gamma_upper_sum_rs_1(arb_t res, ulong p, ulong q, const arb_t z, slong N, slong prec) - slong _arb_hypgeom_gamma_upper_fmpq_inf_choose_N(mag_t err, const fmpq_t a, const arb_t z, const mag_t abs_tol) - void _arb_hypgeom_gamma_upper_fmpq_inf_bsplit(arb_t res, const fmpq_t a, const arb_t z, slong N, slong prec) - slong _arb_hypgeom_gamma_lower_fmpq_0_choose_N(mag_t err, const fmpq_t a, const arb_t z, const mag_t abs_tol) - void _arb_hypgeom_gamma_lower_fmpq_0_bsplit(arb_t res, const fmpq_t a, const arb_t z, slong N, slong prec) - slong _arb_hypgeom_gamma_upper_singular_si_choose_N(mag_t err, slong n, const arb_t z, const mag_t abs_tol) - void _arb_hypgeom_gamma_upper_singular_si_bsplit(arb_t res, slong n, const arb_t z, slong N, slong prec) - void _arb_gamma_upper_fmpq_step_bsplit(arb_t Gz1, const fmpq_t a, const arb_t z0, const arb_t z1, const arb_t Gz0, const arb_t expmz0, const mag_t abs_tol, slong prec) - void arb_hypgeom_expint(arb_t res, const arb_t s, const arb_t z, slong prec) - void arb_hypgeom_ei(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_ei_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_ei_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void _arb_hypgeom_si_asymp(arb_t res, const arb_t z, slong N, slong prec) - void _arb_hypgeom_si_1f2(arb_t res, const arb_t z, slong N, slong wp, slong prec) - void arb_hypgeom_si(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_si_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_si_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void _arb_hypgeom_ci_asymp(arb_t res, const arb_t z, slong N, slong prec) - void _arb_hypgeom_ci_2f3(arb_t res, const arb_t z, slong N, slong wp, slong prec) - void arb_hypgeom_ci(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_ci_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_ci_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_shi(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_shi_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_shi_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_chi(arb_t res, const arb_t z, slong prec) - void _arb_hypgeom_chi_series(arb_ptr res, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_chi_series(arb_poly_t res, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_li(arb_t res, const arb_t z, int offset, slong prec) - void _arb_hypgeom_li_series(arb_ptr res, arb_srcptr z, slong zlen, int offset, slong len, slong prec) - void arb_hypgeom_li_series(arb_poly_t res, const arb_poly_t z, int offset, slong len, slong prec) - void arb_hypgeom_bessel_j(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_y(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_jy(arb_t res1, arb_t res2, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_i(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_i_scaled(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_k(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_k_scaled(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_bessel_i_integration(arb_t res, const arb_t nu, const arb_t z, int scaled, slong prec) - void arb_hypgeom_bessel_k_integration(arb_t res, const arb_t nu, const arb_t z, int scaled, slong prec) - void arb_hypgeom_airy(arb_t ai, arb_t ai_prime, arb_t bi, arb_t bi_prime, const arb_t z, slong prec) - void arb_hypgeom_airy_jet(arb_ptr ai, arb_ptr bi, const arb_t z, slong len, slong prec) - void _arb_hypgeom_airy_series(arb_ptr ai, arb_ptr ai_prime, arb_ptr bi, arb_ptr bi_prime, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_airy_series(arb_poly_t ai, arb_poly_t ai_prime, arb_poly_t bi, arb_poly_t bi_prime, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_airy_zero(arb_t a, arb_t a_prime, arb_t b, arb_t b_prime, const fmpz_t n, slong prec) - void arb_hypgeom_coulomb(arb_t F, arb_t G, const arb_t l, const arb_t eta, const arb_t z, slong prec) - void arb_hypgeom_coulomb_jet(arb_ptr F, arb_ptr G, const arb_t l, const arb_t eta, const arb_t z, slong len, slong prec) - void _arb_hypgeom_coulomb_series(arb_ptr F, arb_ptr G, const arb_t l, const arb_t eta, arb_srcptr z, slong zlen, slong len, slong prec) - void arb_hypgeom_coulomb_series(arb_poly_t F, arb_poly_t G, const arb_t l, const arb_t eta, const arb_poly_t z, slong len, slong prec) - void arb_hypgeom_chebyshev_t(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_chebyshev_u(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_jacobi_p(arb_t res, const arb_t n, const arb_t a, const arb_t b, const arb_t z, slong prec) - void arb_hypgeom_gegenbauer_c(arb_t res, const arb_t n, const arb_t m, const arb_t z, slong prec) - void arb_hypgeom_laguerre_l(arb_t res, const arb_t n, const arb_t m, const arb_t z, slong prec) - void arb_hypgeom_hermite_h(arb_t res, const arb_t nu, const arb_t z, slong prec) - void arb_hypgeom_legendre_p(arb_t res, const arb_t n, const arb_t m, const arb_t z, int type, slong prec) - void arb_hypgeom_legendre_q(arb_t res, const arb_t n, const arb_t m, const arb_t z, int type, slong prec) - void arb_hypgeom_legendre_p_ui_deriv_bound(mag_t dp, mag_t dp2, ulong n, const arb_t x, const arb_t x2sub1) - void arb_hypgeom_legendre_p_ui_zero(arb_t res, arb_t res_prime, ulong n, const arb_t x, slong K, slong prec) - void arb_hypgeom_legendre_p_ui_one(arb_t res, arb_t res_prime, ulong n, const arb_t x, slong K, slong prec) - void arb_hypgeom_legendre_p_ui_asymp(arb_t res, arb_t res_prime, ulong n, const arb_t x, slong K, slong prec) - void arb_hypgeom_legendre_p_ui_rec(arb_t res, arb_t res_prime, ulong n, const arb_t x, slong prec) - void arb_hypgeom_legendre_p_ui(arb_t res, arb_t res_prime, ulong n, const arb_t x, slong prec) - void arb_hypgeom_legendre_p_ui_root(arb_t res, arb_t weight, ulong n, ulong k, slong prec) - void arb_hypgeom_dilog(arb_t res, const arb_t z, slong prec) - void arb_hypgeom_sum_fmpq_arb_forward(arb_t res, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) - void arb_hypgeom_sum_fmpq_arb_rs(arb_t res, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) - void arb_hypgeom_sum_fmpq_arb(arb_t res, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) - void arb_hypgeom_sum_fmpq_imag_arb_forward(arb_t res1, arb_t res2, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) - void arb_hypgeom_sum_fmpq_imag_arb_rs(arb_t res1, arb_t res2, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) - void arb_hypgeom_sum_fmpq_imag_arb_bs(arb_t res1, arb_t res2, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) - void arb_hypgeom_sum_fmpq_imag_arb(arb_t res1, arb_t res2, const fmpq_struct * a, slong alen, const fmpq_struct * b, slong blen, const arb_t z, int reciprocal, slong N, slong prec) diff --git a/src/flint/flintlib/functions/arb_mat.pxd b/src/flint/flintlib/functions/arb_mat.pxd deleted file mode 100644 index b1975edf..00000000 --- a/src/flint/flintlib/functions/arb_mat.pxd +++ /dev/null @@ -1,133 +0,0 @@ -from flint.flintlib.types.arb cimport arb_mat_t, arb_poly_t, arb_ptr, arb_srcptr, arb_t, mag_srcptr, mag_t -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_mat_t -from flint.flintlib.types.fmpz cimport fmpz_mat_t - -# unknown type FILE - -# .. macro:: arb_mat_entry(mat, i, j) -# .. macro:: arb_mat_nrows(mat) -# .. macro:: arb_mat_ncols(mat) - -cdef extern from "flint/arb_mat.h": - void arb_mat_init(arb_mat_t mat, slong r, slong c) - void arb_mat_clear(arb_mat_t mat) - slong arb_mat_allocated_bytes(const arb_mat_t x) - void arb_mat_window_init(arb_mat_t window, const arb_mat_t mat, slong r1, slong c1, slong r2, slong c2) - void arb_mat_window_clear(arb_mat_t window) - void arb_mat_set(arb_mat_t dest, const arb_mat_t src) - void arb_mat_set_fmpz_mat(arb_mat_t dest, const fmpz_mat_t src) - void arb_mat_set_round_fmpz_mat(arb_mat_t dest, const fmpz_mat_t src, slong prec) - void arb_mat_set_fmpq_mat(arb_mat_t dest, const fmpq_mat_t src, slong prec) - void arb_mat_randtest(arb_mat_t mat, flint_rand_t state, slong prec, slong mag_bits) - void arb_mat_randtest_cho(arb_mat_t mat, flint_rand_t state, slong prec, slong mag_bits) - void arb_mat_randtest_spd(arb_mat_t mat, flint_rand_t state, slong prec, slong mag_bits) - void arb_mat_printd(const arb_mat_t mat, slong digits) - # void arb_mat_fprintd(FILE * file, const arb_mat_t mat, slong digits) - int arb_mat_equal(const arb_mat_t mat1, const arb_mat_t mat2) - int arb_mat_overlaps(const arb_mat_t mat1, const arb_mat_t mat2) - int arb_mat_contains(const arb_mat_t mat1, const arb_mat_t mat2) - int arb_mat_contains_fmpz_mat(const arb_mat_t mat1, const fmpz_mat_t mat2) - int arb_mat_contains_fmpq_mat(const arb_mat_t mat1, const fmpq_mat_t mat2) - int arb_mat_eq(const arb_mat_t mat1, const arb_mat_t mat2) - int arb_mat_ne(const arb_mat_t mat1, const arb_mat_t mat2) - int arb_mat_is_empty(const arb_mat_t mat) - int arb_mat_is_square(const arb_mat_t mat) - int arb_mat_is_exact(const arb_mat_t mat) - int arb_mat_is_zero(const arb_mat_t mat) - int arb_mat_is_finite(const arb_mat_t mat) - int arb_mat_is_triu(const arb_mat_t mat) - int arb_mat_is_tril(const arb_mat_t mat) - int arb_mat_is_diag(const arb_mat_t mat) - void arb_mat_zero(arb_mat_t mat) - void arb_mat_one(arb_mat_t mat) - void arb_mat_ones(arb_mat_t mat) - void arb_mat_indeterminate(arb_mat_t mat) - void arb_mat_hilbert(arb_mat_t mat, slong prec) - void arb_mat_pascal(arb_mat_t mat, int triangular, slong prec) - void arb_mat_stirling(arb_mat_t mat, int kind, slong prec) - void arb_mat_dct(arb_mat_t mat, int type, slong prec) - void arb_mat_transpose(arb_mat_t dest, const arb_mat_t src) - void arb_mat_bound_inf_norm(mag_t b, const arb_mat_t A) - void arb_mat_frobenius_norm(arb_t res, const arb_mat_t A, slong prec) - void arb_mat_bound_frobenius_norm(mag_t res, const arb_mat_t A) - void arb_mat_neg(arb_mat_t dest, const arb_mat_t src) - void arb_mat_add(arb_mat_t res, const arb_mat_t mat1, const arb_mat_t mat2, slong prec) - void arb_mat_sub(arb_mat_t res, const arb_mat_t mat1, const arb_mat_t mat2, slong prec) - void arb_mat_mul_classical(arb_mat_t C, const arb_mat_t A, const arb_mat_t B, slong prec) - void arb_mat_mul_threaded(arb_mat_t C, const arb_mat_t A, const arb_mat_t B, slong prec) - void arb_mat_mul_block(arb_mat_t C, const arb_mat_t A, const arb_mat_t B, slong prec) - void arb_mat_mul(arb_mat_t res, const arb_mat_t mat1, const arb_mat_t mat2, slong prec) - void arb_mat_mul_entrywise(arb_mat_t C, const arb_mat_t A, const arb_mat_t B, slong prec) - void arb_mat_sqr_classical(arb_mat_t B, const arb_mat_t A, slong prec) - void arb_mat_sqr(arb_mat_t res, const arb_mat_t mat, slong prec) - void arb_mat_pow_ui(arb_mat_t res, const arb_mat_t mat, ulong exp, slong prec) - void _arb_mat_addmul_rad_mag_fast(arb_mat_t C, mag_srcptr A, mag_srcptr B, slong ar, slong ac, slong bc) - void arb_mat_approx_mul(arb_mat_t res, const arb_mat_t mat1, const arb_mat_t mat2, slong prec) - void arb_mat_scalar_mul_2exp_si(arb_mat_t B, const arb_mat_t A, slong c) - void arb_mat_scalar_addmul_si(arb_mat_t B, const arb_mat_t A, slong c, slong prec) - void arb_mat_scalar_addmul_fmpz(arb_mat_t B, const arb_mat_t A, const fmpz_t c, slong prec) - void arb_mat_scalar_addmul_arb(arb_mat_t B, const arb_mat_t A, const arb_t c, slong prec) - void arb_mat_scalar_mul_si(arb_mat_t B, const arb_mat_t A, slong c, slong prec) - void arb_mat_scalar_mul_fmpz(arb_mat_t B, const arb_mat_t A, const fmpz_t c, slong prec) - void arb_mat_scalar_mul_arb(arb_mat_t B, const arb_mat_t A, const arb_t c, slong prec) - void arb_mat_scalar_div_si(arb_mat_t B, const arb_mat_t A, slong c, slong prec) - void arb_mat_scalar_div_fmpz(arb_mat_t B, const arb_mat_t A, const fmpz_t c, slong prec) - void arb_mat_scalar_div_arb(arb_mat_t B, const arb_mat_t A, const arb_t c, slong prec) - void _arb_mat_vector_mul_row(arb_ptr res, arb_srcptr v, const arb_mat_t A, slong prec) - void _arb_mat_vector_mul_col(arb_ptr res, const arb_mat_t A, arb_srcptr v, slong prec) - void arb_mat_vector_mul_row(arb_ptr res, arb_srcptr v, const arb_mat_t A, slong prec) - void arb_mat_vector_mul_col(arb_ptr res, const arb_mat_t A, arb_srcptr v, slong prec) - int arb_mat_lu_classical(slong * perm, arb_mat_t LU, const arb_mat_t A, slong prec) - int arb_mat_lu_recursive(slong * perm, arb_mat_t LU, const arb_mat_t A, slong prec) - int arb_mat_lu(slong * perm, arb_mat_t LU, const arb_mat_t A, slong prec) - void arb_mat_solve_tril_classical(arb_mat_t X, const arb_mat_t L, const arb_mat_t B, int unit, slong prec) - void arb_mat_solve_tril_recursive(arb_mat_t X, const arb_mat_t L, const arb_mat_t B, int unit, slong prec) - void arb_mat_solve_tril(arb_mat_t X, const arb_mat_t L, const arb_mat_t B, int unit, slong prec) - void arb_mat_solve_triu_classical(arb_mat_t X, const arb_mat_t U, const arb_mat_t B, int unit, slong prec) - void arb_mat_solve_triu_recursive(arb_mat_t X, const arb_mat_t U, const arb_mat_t B, int unit, slong prec) - void arb_mat_solve_triu(arb_mat_t X, const arb_mat_t U, const arb_mat_t B, int unit, slong prec) - void arb_mat_solve_lu_precomp(arb_mat_t X, const slong * perm, const arb_mat_t LU, const arb_mat_t B, slong prec) - int arb_mat_solve(arb_mat_t X, const arb_mat_t A, const arb_mat_t B, slong prec) - int arb_mat_solve_lu(arb_mat_t X, const arb_mat_t A, const arb_mat_t B, slong prec) - int arb_mat_solve_precond(arb_mat_t X, const arb_mat_t A, const arb_mat_t B, slong prec) - int arb_mat_solve_preapprox(arb_mat_t X, const arb_mat_t A, const arb_mat_t B, const arb_mat_t R, const arb_mat_t T, slong prec) - int arb_mat_inv(arb_mat_t X, const arb_mat_t A, slong prec) - void arb_mat_det_lu(arb_t det, const arb_mat_t A, slong prec) - void arb_mat_det_precond(arb_t det, const arb_mat_t A, slong prec) - void arb_mat_det(arb_t det, const arb_mat_t A, slong prec) - void arb_mat_approx_solve_triu(arb_mat_t X, const arb_mat_t U, const arb_mat_t B, int unit, slong prec) - void arb_mat_approx_solve_tril(arb_mat_t X, const arb_mat_t L, const arb_mat_t B, int unit, slong prec) - int arb_mat_approx_lu(slong * P, arb_mat_t LU, const arb_mat_t A, slong prec) - void arb_mat_approx_solve_lu_precomp(arb_mat_t X, const slong * perm, const arb_mat_t A, const arb_mat_t B, slong prec) - int arb_mat_approx_solve(arb_mat_t X, const arb_mat_t A, const arb_mat_t B, slong prec) - int arb_mat_approx_inv(arb_mat_t X, const arb_mat_t A, slong prec) - int _arb_mat_cholesky_banachiewicz(arb_mat_t A, slong prec) - int arb_mat_cho(arb_mat_t L, const arb_mat_t A, slong prec) - void arb_mat_solve_cho_precomp(arb_mat_t X, const arb_mat_t L, const arb_mat_t B, slong prec) - int arb_mat_spd_solve(arb_mat_t X, const arb_mat_t A, const arb_mat_t B, slong prec) - void arb_mat_inv_cho_precomp(arb_mat_t X, const arb_mat_t L, slong prec) - int arb_mat_spd_inv(arb_mat_t X, const arb_mat_t A, slong prec) - int _arb_mat_ldl_inplace(arb_mat_t A, slong prec) - int _arb_mat_ldl_golub_and_van_loan(arb_mat_t A, slong prec) - int arb_mat_ldl(arb_mat_t res, const arb_mat_t A, slong prec) - void arb_mat_solve_ldl_precomp(arb_mat_t X, const arb_mat_t L, const arb_mat_t B, slong prec) - void arb_mat_inv_ldl_precomp(arb_mat_t X, const arb_mat_t L, slong prec) - void _arb_mat_charpoly(arb_ptr poly, const arb_mat_t mat, slong prec) - void arb_mat_charpoly(arb_poly_t poly, const arb_mat_t mat, slong prec) - void _arb_mat_companion(arb_mat_t mat, arb_srcptr poly, slong prec) - void arb_mat_companion(arb_mat_t mat, const arb_poly_t poly, slong prec) - void arb_mat_exp_taylor_sum(arb_mat_t S, const arb_mat_t A, slong N, slong prec) - void arb_mat_exp(arb_mat_t B, const arb_mat_t A, slong prec) - void arb_mat_trace(arb_t trace, const arb_mat_t mat, slong prec) - void _arb_mat_diag_prod(arb_t res, const arb_mat_t mat, slong a, slong b, slong prec) - void arb_mat_diag_prod(arb_t res, const arb_mat_t mat, slong prec) - void arb_mat_entrywise_is_zero(fmpz_mat_t dest, const arb_mat_t src) - void arb_mat_entrywise_not_is_zero(fmpz_mat_t dest, const arb_mat_t src) - slong arb_mat_count_is_zero(const arb_mat_t mat) - slong arb_mat_count_not_is_zero(const arb_mat_t mat) - void arb_mat_get_mid(arb_mat_t B, const arb_mat_t A) - void arb_mat_add_error_mag(arb_mat_t mat, const mag_t err) - int arb_mat_spd_get_fmpz_mat(fmpz_mat_t B, const arb_mat_t A, slong prec) - void arb_mat_spd_lll_reduce(fmpz_mat_t U, const arb_mat_t A, slong prec) - int arb_mat_spd_is_lll_reduced(const arb_mat_t A, slong tol_exp, slong prec) diff --git a/src/flint/flintlib/functions/arb_poly.pxd b/src/flint/flintlib/functions/arb_poly.pxd deleted file mode 100644 index 429534de..00000000 --- a/src/flint/flintlib/functions/arb_poly.pxd +++ /dev/null @@ -1,231 +0,0 @@ -from flint.flintlib.types.acb cimport acb_srcptr, acb_t -from flint.flintlib.types.arb cimport arb_poly_t, arb_ptr, arb_srcptr, arb_t, mag_t -from flint.flintlib.types.arf cimport arf_t -from flint.flintlib.types.flint cimport flint_rand_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_poly_t -from flint.flintlib.types.fmpz cimport fmpz_poly_t - -# unknown type FILE - -# .. macro:: arb_poly_get_coeff_ptr(poly, n) - -cdef extern from "flint/arb_poly.h": - void arb_poly_init(arb_poly_t poly) - void arb_poly_clear(arb_poly_t poly) - void arb_poly_fit_length(arb_poly_t poly, slong len) - void _arb_poly_set_length(arb_poly_t poly, slong len) - void _arb_poly_normalise(arb_poly_t poly) - slong arb_poly_allocated_bytes(const arb_poly_t x) - slong arb_poly_length(const arb_poly_t poly) - slong arb_poly_degree(const arb_poly_t poly) - int arb_poly_is_zero(const arb_poly_t poly) - int arb_poly_is_one(const arb_poly_t poly) - int arb_poly_is_x(const arb_poly_t poly) - void arb_poly_zero(arb_poly_t poly) - void arb_poly_one(arb_poly_t poly) - void arb_poly_set(arb_poly_t dest, const arb_poly_t src) - void arb_poly_set_round(arb_poly_t dest, const arb_poly_t src, slong prec) - void arb_poly_set_trunc(arb_poly_t dest, const arb_poly_t src, slong n) - void arb_poly_set_trunc_round(arb_poly_t dest, const arb_poly_t src, slong n, slong prec) - void arb_poly_set_coeff_si(arb_poly_t poly, slong n, slong c) - void arb_poly_set_coeff_arb(arb_poly_t poly, slong n, const arb_t c) - void arb_poly_get_coeff_arb(arb_t v, const arb_poly_t poly, slong n) - void _arb_poly_shift_right(arb_ptr res, arb_srcptr poly, slong len, slong n) - void arb_poly_shift_right(arb_poly_t res, const arb_poly_t poly, slong n) - void _arb_poly_shift_left(arb_ptr res, arb_srcptr poly, slong len, slong n) - void arb_poly_shift_left(arb_poly_t res, const arb_poly_t poly, slong n) - void arb_poly_truncate(arb_poly_t poly, slong n) - slong arb_poly_valuation(const arb_poly_t poly) - void arb_poly_set_fmpz_poly(arb_poly_t poly, const fmpz_poly_t src, slong prec) - void arb_poly_set_fmpq_poly(arb_poly_t poly, const fmpq_poly_t src, slong prec) - void arb_poly_set_si(arb_poly_t poly, slong src) - void arb_poly_printd(const arb_poly_t poly, slong digits) - # void arb_poly_fprintd(FILE * file, const arb_poly_t poly, slong digits) - void arb_poly_randtest(arb_poly_t poly, flint_rand_t state, slong len, slong prec, slong mag_bits) - int arb_poly_contains(const arb_poly_t poly1, const arb_poly_t poly2) - int arb_poly_contains_fmpz_poly(const arb_poly_t poly1, const fmpz_poly_t poly2) - int arb_poly_contains_fmpq_poly(const arb_poly_t poly1, const fmpq_poly_t poly2) - int arb_poly_equal(const arb_poly_t A, const arb_poly_t B) - int _arb_poly_overlaps(arb_srcptr poly1, slong len1, arb_srcptr poly2, slong len2) - int arb_poly_overlaps(const arb_poly_t poly1, const arb_poly_t poly2) - int arb_poly_get_unique_fmpz_poly(fmpz_poly_t z, const arb_poly_t x) - void _arb_poly_majorant(arb_ptr res, arb_srcptr poly, slong len, slong prec) - void arb_poly_majorant(arb_poly_t res, const arb_poly_t poly, slong prec) - void _arb_poly_add(arb_ptr C, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong prec) - void arb_poly_add(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong prec) - void arb_poly_add_si(arb_poly_t C, const arb_poly_t A, slong B, slong prec) - void _arb_poly_sub(arb_ptr C, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong prec) - void arb_poly_sub(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong prec) - void arb_poly_add_series(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong len, slong prec) - void arb_poly_sub_series(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong len, slong prec) - void arb_poly_neg(arb_poly_t C, const arb_poly_t A) - void arb_poly_scalar_mul_2exp_si(arb_poly_t C, const arb_poly_t A, slong c) - void arb_poly_scalar_mul(arb_poly_t C, const arb_poly_t A, const arb_t c, slong prec) - void arb_poly_scalar_div(arb_poly_t C, const arb_poly_t A, const arb_t c, slong prec) - void _arb_poly_mullow_classical(arb_ptr C, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong n, slong prec) - void _arb_poly_mullow_block(arb_ptr C, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong n, slong prec) - void _arb_poly_mullow(arb_ptr C, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong n, slong prec) - void arb_poly_mullow_classical(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong n, slong prec) - void arb_poly_mullow_block(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong n, slong prec) - void arb_poly_mullow(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong n, slong prec) - void _arb_poly_mul(arb_ptr C, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong prec) - void arb_poly_mul(arb_poly_t C, const arb_poly_t A, const arb_poly_t B, slong prec) - void _arb_poly_inv_series(arb_ptr Q, arb_srcptr A, slong Alen, slong len, slong prec) - void arb_poly_inv_series(arb_poly_t Q, const arb_poly_t A, slong n, slong prec) - void _arb_poly_div_series(arb_ptr Q, arb_srcptr A, slong Alen, arb_srcptr B, slong Blen, slong n, slong prec) - void arb_poly_div_series(arb_poly_t Q, const arb_poly_t A, const arb_poly_t B, slong n, slong prec) - void _arb_poly_div(arb_ptr Q, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong prec) - void _arb_poly_rem(arb_ptr R, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong prec) - void _arb_poly_divrem(arb_ptr Q, arb_ptr R, arb_srcptr A, slong lenA, arb_srcptr B, slong lenB, slong prec) - int arb_poly_divrem(arb_poly_t Q, arb_poly_t R, const arb_poly_t A, const arb_poly_t B, slong prec) - void _arb_poly_div_root(arb_ptr Q, arb_t R, arb_srcptr A, slong len, const arb_t c, slong prec) - void _arb_poly_taylor_shift(arb_ptr g, const arb_t c, slong n, slong prec) - void arb_poly_taylor_shift(arb_poly_t g, const arb_poly_t f, const arb_t c, slong prec) - void _arb_poly_compose(arb_ptr res, arb_srcptr poly1, slong len1, arb_srcptr poly2, slong len2, slong prec) - void arb_poly_compose(arb_poly_t res, const arb_poly_t poly1, const arb_poly_t poly2, slong prec) - void _arb_poly_compose_series(arb_ptr res, arb_srcptr poly1, slong len1, arb_srcptr poly2, slong len2, slong n, slong prec) - void arb_poly_compose_series(arb_poly_t res, const arb_poly_t poly1, const arb_poly_t poly2, slong n, slong prec) - void _arb_poly_revert_series(arb_ptr h, arb_srcptr f, slong flen, slong n, slong prec) - void arb_poly_revert_series(arb_poly_t h, const arb_poly_t f, slong n, slong prec) - void _arb_poly_evaluate_horner(arb_t y, arb_srcptr f, slong len, const arb_t x, slong prec) - void arb_poly_evaluate_horner(arb_t y, const arb_poly_t f, const arb_t x, slong prec) - void _arb_poly_evaluate_rectangular(arb_t y, arb_srcptr f, slong len, const arb_t x, slong prec) - void arb_poly_evaluate_rectangular(arb_t y, const arb_poly_t f, const arb_t x, slong prec) - void _arb_poly_evaluate(arb_t y, arb_srcptr f, slong len, const arb_t x, slong prec) - void arb_poly_evaluate(arb_t y, const arb_poly_t f, const arb_t x, slong prec) - void _arb_poly_evaluate_acb_horner(acb_t y, arb_srcptr f, slong len, const acb_t x, slong prec) - void arb_poly_evaluate_acb_horner(acb_t y, const arb_poly_t f, const acb_t x, slong prec) - void _arb_poly_evaluate_acb_rectangular(acb_t y, arb_srcptr f, slong len, const acb_t x, slong prec) - void arb_poly_evaluate_acb_rectangular(acb_t y, const arb_poly_t f, const acb_t x, slong prec) - void _arb_poly_evaluate_acb(acb_t y, arb_srcptr f, slong len, const acb_t x, slong prec) - void arb_poly_evaluate_acb(acb_t y, const arb_poly_t f, const acb_t x, slong prec) - void _arb_poly_evaluate2_horner(arb_t y, arb_t z, arb_srcptr f, slong len, const arb_t x, slong prec) - void arb_poly_evaluate2_horner(arb_t y, arb_t z, const arb_poly_t f, const arb_t x, slong prec) - void _arb_poly_evaluate2_rectangular(arb_t y, arb_t z, arb_srcptr f, slong len, const arb_t x, slong prec) - void arb_poly_evaluate2_rectangular(arb_t y, arb_t z, const arb_poly_t f, const arb_t x, slong prec) - void _arb_poly_evaluate2(arb_t y, arb_t z, arb_srcptr f, slong len, const arb_t x, slong prec) - void arb_poly_evaluate2(arb_t y, arb_t z, const arb_poly_t f, const arb_t x, slong prec) - void _arb_poly_evaluate2_acb_horner(acb_t y, acb_t z, arb_srcptr f, slong len, const acb_t x, slong prec) - void arb_poly_evaluate2_acb_horner(acb_t y, acb_t z, const arb_poly_t f, const acb_t x, slong prec) - void _arb_poly_evaluate2_acb_rectangular(acb_t y, acb_t z, arb_srcptr f, slong len, const acb_t x, slong prec) - void arb_poly_evaluate2_acb_rectangular(acb_t y, acb_t z, const arb_poly_t f, const acb_t x, slong prec) - void _arb_poly_evaluate2_acb(acb_t y, acb_t z, arb_srcptr f, slong len, const acb_t x, slong prec) - void arb_poly_evaluate2_acb(acb_t y, acb_t z, const arb_poly_t f, const acb_t x, slong prec) - void _arb_poly_product_roots(arb_ptr poly, arb_srcptr xs, slong n, slong prec) - void arb_poly_product_roots(arb_poly_t poly, arb_srcptr xs, slong n, slong prec) - void _arb_poly_product_roots_complex(arb_ptr poly, arb_srcptr r, slong rn, acb_srcptr c, slong cn, slong prec) - void arb_poly_product_roots_complex(arb_poly_t poly, arb_srcptr r, slong rn, acb_srcptr c, slong cn, slong prec) - arb_ptr * _arb_poly_tree_alloc(slong len) - void _arb_poly_tree_free(arb_ptr * tree, slong len) - void _arb_poly_tree_build(arb_ptr * tree, arb_srcptr roots, slong len, slong prec) - void _arb_poly_evaluate_vec_iter(arb_ptr ys, arb_srcptr poly, slong plen, arb_srcptr xs, slong n, slong prec) - void arb_poly_evaluate_vec_iter(arb_ptr ys, const arb_poly_t poly, arb_srcptr xs, slong n, slong prec) - void _arb_poly_evaluate_vec_fast_precomp(arb_ptr vs, arb_srcptr poly, slong plen, arb_ptr * tree, slong len, slong prec) - void _arb_poly_evaluate_vec_fast(arb_ptr ys, arb_srcptr poly, slong plen, arb_srcptr xs, slong n, slong prec) - void arb_poly_evaluate_vec_fast(arb_ptr ys, const arb_poly_t poly, arb_srcptr xs, slong n, slong prec) - void _arb_poly_interpolate_newton(arb_ptr poly, arb_srcptr xs, arb_srcptr ys, slong n, slong prec) - void arb_poly_interpolate_newton(arb_poly_t poly, arb_srcptr xs, arb_srcptr ys, slong n, slong prec) - void _arb_poly_interpolate_barycentric(arb_ptr poly, arb_srcptr xs, arb_srcptr ys, slong n, slong prec) - void arb_poly_interpolate_barycentric(arb_poly_t poly, arb_srcptr xs, arb_srcptr ys, slong n, slong prec) - void _arb_poly_interpolation_weights(arb_ptr w, arb_ptr * tree, slong len, slong prec) - void _arb_poly_interpolate_fast_precomp(arb_ptr poly, arb_srcptr ys, arb_ptr * tree, arb_srcptr weights, slong len, slong prec) - void _arb_poly_interpolate_fast(arb_ptr poly, arb_srcptr xs, arb_srcptr ys, slong len, slong prec) - void arb_poly_interpolate_fast(arb_poly_t poly, arb_srcptr xs, arb_srcptr ys, slong n, slong prec) - void _arb_poly_derivative(arb_ptr res, arb_srcptr poly, slong len, slong prec) - void arb_poly_derivative(arb_poly_t res, const arb_poly_t poly, slong prec) - void _arb_poly_nth_derivative(arb_ptr res, arb_srcptr poly, ulong n, slong len, slong prec) - void arb_poly_nth_derivative(arb_poly_t res, const arb_poly_t poly, ulong n, slong prec) - void _arb_poly_integral(arb_ptr res, arb_srcptr poly, slong len, slong prec) - void arb_poly_integral(arb_poly_t res, const arb_poly_t poly, slong prec) - void _arb_poly_borel_transform(arb_ptr res, arb_srcptr poly, slong len, slong prec) - void arb_poly_borel_transform(arb_poly_t res, const arb_poly_t poly, slong prec) - void _arb_poly_inv_borel_transform(arb_ptr res, arb_srcptr poly, slong len, slong prec) - void arb_poly_inv_borel_transform(arb_poly_t res, const arb_poly_t poly, slong prec) - void _arb_poly_binomial_transform_basecase(arb_ptr b, arb_srcptr a, slong alen, slong len, slong prec) - void arb_poly_binomial_transform_basecase(arb_poly_t b, const arb_poly_t a, slong len, slong prec) - void _arb_poly_binomial_transform_convolution(arb_ptr b, arb_srcptr a, slong alen, slong len, slong prec) - void arb_poly_binomial_transform_convolution(arb_poly_t b, const arb_poly_t a, slong len, slong prec) - void _arb_poly_binomial_transform(arb_ptr b, arb_srcptr a, slong alen, slong len, slong prec) - void arb_poly_binomial_transform(arb_poly_t b, const arb_poly_t a, slong len, slong prec) - void _arb_poly_graeffe_transform(arb_ptr b, arb_srcptr a, slong len, slong prec) - void arb_poly_graeffe_transform(arb_poly_t b, const arb_poly_t a, slong prec) - void _arb_poly_pow_ui_trunc_binexp(arb_ptr res, arb_srcptr f, slong flen, ulong exp, slong len, slong prec) - void arb_poly_pow_ui_trunc_binexp(arb_poly_t res, const arb_poly_t poly, ulong exp, slong len, slong prec) - void _arb_poly_pow_ui(arb_ptr res, arb_srcptr f, slong flen, ulong exp, slong prec) - void arb_poly_pow_ui(arb_poly_t res, const arb_poly_t poly, ulong exp, slong prec) - void _arb_poly_pow_series(arb_ptr h, arb_srcptr f, slong flen, arb_srcptr g, slong glen, slong len, slong prec) - void arb_poly_pow_series(arb_poly_t h, const arb_poly_t f, const arb_poly_t g, slong len, slong prec) - void _arb_poly_pow_arb_series(arb_ptr h, arb_srcptr f, slong flen, const arb_t g, slong len, slong prec) - void arb_poly_pow_arb_series(arb_poly_t h, const arb_poly_t f, const arb_t g, slong len, slong prec) - void _arb_poly_sqrt_series(arb_ptr g, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sqrt_series(arb_poly_t g, const arb_poly_t h, slong n, slong prec) - void _arb_poly_rsqrt_series(arb_ptr g, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_rsqrt_series(arb_poly_t g, const arb_poly_t h, slong n, slong prec) - void _arb_poly_log_series(arb_ptr res, arb_srcptr f, slong flen, slong n, slong prec) - void arb_poly_log_series(arb_poly_t res, const arb_poly_t f, slong n, slong prec) - void _arb_poly_log1p_series(arb_ptr res, arb_srcptr f, slong flen, slong n, slong prec) - void arb_poly_log1p_series(arb_poly_t res, const arb_poly_t f, slong n, slong prec) - void _arb_poly_atan_series(arb_ptr res, arb_srcptr f, slong flen, slong n, slong prec) - void arb_poly_atan_series(arb_poly_t res, const arb_poly_t f, slong n, slong prec) - void _arb_poly_asin_series(arb_ptr res, arb_srcptr f, slong flen, slong n, slong prec) - void arb_poly_asin_series(arb_poly_t res, const arb_poly_t f, slong n, slong prec) - void _arb_poly_acos_series(arb_ptr res, arb_srcptr f, slong flen, slong n, slong prec) - void arb_poly_acos_series(arb_poly_t res, const arb_poly_t f, slong n, slong prec) - void _arb_poly_exp_series_basecase(arb_ptr f, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_exp_series_basecase(arb_poly_t f, const arb_poly_t h, slong n, slong prec) - void _arb_poly_exp_series(arb_ptr f, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_exp_series(arb_poly_t f, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sin_cos_series(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sin_cos_series(arb_poly_t s, arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sin_series(arb_ptr s, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sin_series(arb_poly_t s, const arb_poly_t h, slong n, slong prec) - void _arb_poly_cos_series(arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_cos_series(arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_tan_series(arb_ptr g, arb_srcptr h, slong hlen, slong len, slong prec) - void arb_poly_tan_series(arb_poly_t g, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sin_cos_pi_series(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sin_cos_pi_series(arb_poly_t s, arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sin_pi_series(arb_ptr s, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sin_pi_series(arb_poly_t s, const arb_poly_t h, slong n, slong prec) - void _arb_poly_cos_pi_series(arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_cos_pi_series(arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_cot_pi_series(arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_cot_pi_series(arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sinh_cosh_series_basecase(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sinh_cosh_series_basecase(arb_poly_t s, arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sinh_cosh_series_exponential(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sinh_cosh_series_exponential(arb_poly_t s, arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sinh_cosh_series(arb_ptr s, arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sinh_cosh_series(arb_poly_t s, arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sinh_series(arb_ptr s, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sinh_series(arb_poly_t s, const arb_poly_t h, slong n, slong prec) - void _arb_poly_cosh_series(arb_ptr c, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_cosh_series(arb_poly_t c, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sinc_series(arb_ptr s, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sinc_series(arb_poly_t s, const arb_poly_t h, slong n, slong prec) - void _arb_poly_sinc_pi_series(arb_ptr s, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_sinc_pi_series(arb_poly_t s, const arb_poly_t h, slong n, slong prec) - void _arb_poly_lambertw_series(arb_ptr res, arb_srcptr z, slong zlen, int flags, slong len, slong prec) - void arb_poly_lambertw_series(arb_poly_t res, const arb_poly_t z, int flags, slong len, slong prec) - void _arb_poly_gamma_series(arb_ptr res, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_gamma_series(arb_poly_t res, const arb_poly_t h, slong n, slong prec) - void _arb_poly_rgamma_series(arb_ptr res, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_rgamma_series(arb_poly_t res, const arb_poly_t h, slong n, slong prec) - void _arb_poly_lgamma_series(arb_ptr res, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_lgamma_series(arb_poly_t res, const arb_poly_t h, slong n, slong prec) - void _arb_poly_digamma_series(arb_ptr res, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_digamma_series(arb_poly_t res, const arb_poly_t h, slong n, slong prec) - void _arb_poly_rising_ui_series(arb_ptr res, arb_srcptr f, slong flen, ulong r, slong trunc, slong prec) - void arb_poly_rising_ui_series(arb_poly_t res, const arb_poly_t f, ulong r, slong trunc, slong prec) - void arb_poly_zeta_series(arb_poly_t res, const arb_poly_t s, const arb_t a, int deflate, slong n, slong prec) - void _arb_poly_riemann_siegel_theta_series(arb_ptr res, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_riemann_siegel_theta_series(arb_poly_t res, const arb_poly_t h, slong n, slong prec) - void _arb_poly_riemann_siegel_z_series(arb_ptr res, arb_srcptr h, slong hlen, slong n, slong prec) - void arb_poly_riemann_siegel_z_series(arb_poly_t res, const arb_poly_t h, slong n, slong prec) - void _arb_poly_root_bound_fujiwara(mag_t bound, arb_srcptr poly, slong len) - void arb_poly_root_bound_fujiwara(mag_t bound, arb_poly_t poly) - void _arb_poly_newton_convergence_factor(arf_t convergence_factor, arb_srcptr poly, slong len, const arb_t convergence_interval, slong prec) - int _arb_poly_newton_step(arb_t xnew, arb_srcptr poly, slong len, const arb_t x, const arb_t convergence_interval, const arf_t convergence_factor, slong prec) - void _arb_poly_newton_refine_root(arb_t r, arb_srcptr poly, slong len, const arb_t start, const arb_t convergence_interval, const arf_t convergence_factor, slong eval_extra_prec, slong prec) - void _arb_poly_swinnerton_dyer_ui(arb_ptr poly, ulong n, slong trunc, slong prec) - void arb_poly_swinnerton_dyer_ui(arb_poly_t poly, ulong n, slong prec) diff --git a/src/flint/flintlib/functions/arf.pxd b/src/flint/flintlib/functions/arf.pxd deleted file mode 100644 index 3abbc68f..00000000 --- a/src/flint/flintlib/functions/arf.pxd +++ /dev/null @@ -1,169 +0,0 @@ -from flint.flintlib.types.arb cimport mag_t -from flint.flintlib.types.arf cimport arf_rnd_t, arf_srcptr, arf_t -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t - -# unknown type FILE -# unknown type mpfr_rnd_t -# unknown type mpfr_t -# unknown type mpz_t - -# .. macro:: ARF_RND_DOWN -# .. macro:: ARF_RND_UP -# .. macro:: ARF_RND_FLOOR -# .. macro:: ARF_RND_CEIL -# .. macro:: ARF_RND_NEAR -# .. macro:: ARF_PREC_EXACT - -cdef extern from "flint/arf.h": - void arf_init(arf_t x) - void arf_clear(arf_t x) - slong arf_allocated_bytes(const arf_t x) - void arf_zero(arf_t res) - void arf_one(arf_t res) - void arf_pos_inf(arf_t res) - void arf_neg_inf(arf_t res) - void arf_nan(arf_t res) - int arf_is_zero(const arf_t x) - int arf_is_one(const arf_t x) - int arf_is_pos_inf(const arf_t x) - int arf_is_neg_inf(const arf_t x) - int arf_is_nan(const arf_t x) - int arf_is_inf(const arf_t x) - int arf_is_normal(const arf_t x) - int arf_is_special(const arf_t x) - int arf_is_finite(const arf_t x) - void arf_set(arf_t res, const arf_t x) - # void arf_set_mpz(arf_t res, const mpz_t x) - void arf_set_fmpz(arf_t res, const fmpz_t x) - void arf_set_ui(arf_t res, ulong x) - void arf_set_si(arf_t res, slong x) - # void arf_set_mpfr(arf_t res, const mpfr_t x) - void arf_set_d(arf_t res, double x) - void arf_swap(arf_t x, arf_t y) - void arf_init_set_ui(arf_t res, ulong x) - void arf_init_set_si(arf_t res, slong x) - int arf_set_round(arf_t res, const arf_t x, slong prec, arf_rnd_t rnd) - int arf_set_round_si(arf_t res, slong x, slong prec, arf_rnd_t rnd) - int arf_set_round_ui(arf_t res, ulong x, slong prec, arf_rnd_t rnd) - # int arf_set_round_mpz(arf_t res, const mpz_t x, slong prec, arf_rnd_t rnd) - int arf_set_round_fmpz(arf_t res, const fmpz_t x, slong prec, arf_rnd_t rnd) - void arf_set_si_2exp_si(arf_t res, slong m, slong e) - void arf_set_ui_2exp_si(arf_t res, ulong m, slong e) - void arf_set_fmpz_2exp(arf_t res, const fmpz_t m, const fmpz_t e) - int arf_set_round_fmpz_2exp(arf_t res, const fmpz_t x, const fmpz_t e, slong prec, arf_rnd_t rnd) - void arf_get_fmpz_2exp(fmpz_t m, fmpz_t e, const arf_t x) - void arf_frexp(arf_t m, fmpz_t e, const arf_t x) - double arf_get_d(const arf_t x, arf_rnd_t rnd) - # int arf_get_mpfr(mpfr_t res, const arf_t x, mpfr_rnd_t rnd) - int arf_get_fmpz(fmpz_t res, const arf_t x, arf_rnd_t rnd) - slong arf_get_si(const arf_t x, arf_rnd_t rnd) - int arf_get_fmpz_fixed_fmpz(fmpz_t res, const arf_t x, const fmpz_t e) - int arf_get_fmpz_fixed_si(fmpz_t res, const arf_t x, slong e) - void arf_floor(arf_t res, const arf_t x) - void arf_ceil(arf_t res, const arf_t x) - void arf_nint(arf_t res, const arf_t x) - void arf_get_fmpq(fmpq_t res, const arf_t x) - int arf_equal(const arf_t x, const arf_t y) - int arf_equal_si(const arf_t x, slong y) - int arf_equal_ui(const arf_t x, ulong y) - int arf_equal_d(const arf_t x, double y) - int arf_cmp(const arf_t x, const arf_t y) - int arf_cmp_si(const arf_t x, slong y) - int arf_cmp_ui(const arf_t x, ulong y) - int arf_cmp_d(const arf_t x, double y) - int arf_cmpabs(const arf_t x, const arf_t y) - int arf_cmpabs_ui(const arf_t x, ulong y) - int arf_cmpabs_d(const arf_t x, double y) - int arf_cmpabs_mag(const arf_t x, const mag_t y) - int arf_cmp_2exp_si(const arf_t x, slong e) - int arf_cmpabs_2exp_si(const arf_t x, slong e) - int arf_sgn(const arf_t x) - void arf_min(arf_t res, const arf_t a, const arf_t b) - void arf_max(arf_t res, const arf_t a, const arf_t b) - slong arf_bits(const arf_t x) - int arf_is_int(const arf_t x) - int arf_is_int_2exp_si(const arf_t x, slong e) - void arf_abs_bound_lt_2exp_fmpz(fmpz_t res, const arf_t x) - void arf_abs_bound_le_2exp_fmpz(fmpz_t res, const arf_t x) - slong arf_abs_bound_lt_2exp_si(const arf_t x) - void arf_get_mag(mag_t res, const arf_t x) - void arf_get_mag_lower(mag_t res, const arf_t x) - void arf_set_mag(arf_t res, const mag_t x) - void mag_init_set_arf(mag_t res, const arf_t x) - void mag_fast_init_set_arf(mag_t res, const arf_t x) - void arf_mag_set_ulp(mag_t res, const arf_t x, slong prec) - void arf_mag_add_ulp(mag_t res, const mag_t x, const arf_t y, slong prec) - void arf_mag_fast_add_ulp(mag_t res, const mag_t x, const arf_t y, slong prec) - void arf_init_set_shallow(arf_t z, const arf_t x) - void arf_init_set_mag_shallow(arf_t z, const mag_t x) - void arf_init_neg_shallow(arf_t z, const arf_t x) - void arf_init_neg_mag_shallow(arf_t z, const mag_t x) - void arf_randtest(arf_t res, flint_rand_t state, slong bits, slong mag_bits) - void arf_randtest_not_zero(arf_t res, flint_rand_t state, slong bits, slong mag_bits) - void arf_randtest_special(arf_t res, flint_rand_t state, slong bits, slong mag_bits) - void arf_urandom(arf_t res, flint_rand_t state, slong bits, arf_rnd_t rnd) - void arf_debug(const arf_t x) - void arf_print(const arf_t x) - void arf_printd(const arf_t x, slong d) - char * arf_get_str(const arf_t x, slong d) - # void arf_fprint(FILE * file, const arf_t x) - # void arf_fprintd(FILE * file, const arf_t y, slong d) - char * arf_dump_str(const arf_t x) - int arf_load_str(arf_t x, const char * str) - # int arf_dump_file(FILE * stream, const arf_t x) - # int arf_load_file(arf_t x, FILE * stream) - void arf_abs(arf_t res, const arf_t x) - void arf_neg(arf_t res, const arf_t x) - int arf_neg_round(arf_t res, const arf_t x, slong prec, arf_rnd_t rnd) - int arf_add(arf_t res, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_add_si(arf_t res, const arf_t x, slong y, slong prec, arf_rnd_t rnd) - int arf_add_ui(arf_t res, const arf_t x, ulong y, slong prec, arf_rnd_t rnd) - int arf_add_fmpz(arf_t res, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - int arf_add_fmpz_2exp(arf_t res, const arf_t x, const fmpz_t y, const fmpz_t e, slong prec, arf_rnd_t rnd) - int arf_sub(arf_t res, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_sub_si(arf_t res, const arf_t x, slong y, slong prec, arf_rnd_t rnd) - int arf_sub_ui(arf_t res, const arf_t x, ulong y, slong prec, arf_rnd_t rnd) - int arf_sub_fmpz(arf_t res, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - void arf_mul_2exp_si(arf_t res, const arf_t x, slong e) - void arf_mul_2exp_fmpz(arf_t res, const arf_t x, const fmpz_t e) - int arf_mul(arf_t res, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_mul_ui(arf_t res, const arf_t x, ulong y, slong prec, arf_rnd_t rnd) - int arf_mul_si(arf_t res, const arf_t x, slong y, slong prec, arf_rnd_t rnd) - # int arf_mul_mpz(arf_t res, const arf_t x, const mpz_t y, slong prec, arf_rnd_t rnd) - int arf_mul_fmpz(arf_t res, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - int arf_addmul(arf_t z, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_addmul_ui(arf_t z, const arf_t x, ulong y, slong prec, arf_rnd_t rnd) - int arf_addmul_si(arf_t z, const arf_t x, slong y, slong prec, arf_rnd_t rnd) - # int arf_addmul_mpz(arf_t z, const arf_t x, const mpz_t y, slong prec, arf_rnd_t rnd) - int arf_addmul_fmpz(arf_t z, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - int arf_submul(arf_t z, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_submul_ui(arf_t z, const arf_t x, ulong y, slong prec, arf_rnd_t rnd) - int arf_submul_si(arf_t z, const arf_t x, slong y, slong prec, arf_rnd_t rnd) - # int arf_submul_mpz(arf_t z, const arf_t x, const mpz_t y, slong prec, arf_rnd_t rnd) - int arf_submul_fmpz(arf_t z, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - int arf_fma(arf_t res, const arf_t x, const arf_t y, const arf_t z, slong prec, arf_rnd_t rnd) - int arf_sosq(arf_t res, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_sum(arf_t res, arf_srcptr terms, slong len, slong prec, arf_rnd_t rnd) - void arf_approx_dot(arf_t res, const arf_t initial, int subtract, arf_srcptr x, slong xstep, arf_srcptr y, slong ystep, slong len, slong prec, arf_rnd_t rnd) - int arf_div(arf_t res, const arf_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_div_ui(arf_t res, const arf_t x, ulong y, slong prec, arf_rnd_t rnd) - int arf_ui_div(arf_t res, ulong x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_div_si(arf_t res, const arf_t x, slong y, slong prec, arf_rnd_t rnd) - int arf_si_div(arf_t res, slong x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_div_fmpz(arf_t res, const arf_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - int arf_fmpz_div(arf_t res, const fmpz_t x, const arf_t y, slong prec, arf_rnd_t rnd) - int arf_fmpz_div_fmpz(arf_t res, const fmpz_t x, const fmpz_t y, slong prec, arf_rnd_t rnd) - int arf_sqrt(arf_t res, const arf_t x, slong prec, arf_rnd_t rnd) - int arf_sqrt_ui(arf_t res, ulong x, slong prec, arf_rnd_t rnd) - int arf_sqrt_fmpz(arf_t res, const fmpz_t x, slong prec, arf_rnd_t rnd) - int arf_rsqrt(arf_t res, const arf_t x, slong prec, arf_rnd_t rnd) - int arf_root(arf_t res, const arf_t x, ulong k, slong prec, arf_rnd_t rnd) - int arf_complex_mul(arf_t e, arf_t f, const arf_t a, const arf_t b, const arf_t c, const arf_t d, slong prec, arf_rnd_t rnd) - int arf_complex_mul_fallback(arf_t e, arf_t f, const arf_t a, const arf_t b, const arf_t c, const arf_t d, slong prec, arf_rnd_t rnd) - int arf_complex_sqr(arf_t e, arf_t f, const arf_t a, const arf_t b, slong prec, arf_rnd_t rnd) - int _arf_get_integer_mpn(nn_ptr y, nn_srcptr xp, slong xn, slong exp) - int _arf_set_mpn_fixed(arf_t z, nn_srcptr xp, slong xn, slong fixn, int negative, slong prec, arf_rnd_t rnd) - int _arf_set_round_ui(arf_t z, ulong x, int sgnbit, slong prec, arf_rnd_t rnd) - int _arf_set_round_uiui(arf_t z, slong * fix, ulong hi, ulong lo, int sgnbit, slong prec, arf_rnd_t rnd) - int _arf_set_round_mpn(arf_t z, slong * exp_shift, nn_srcptr x, slong xn, int sgnbit, slong prec, arf_rnd_t rnd) diff --git a/src/flint/flintlib/functions/arith.pxd b/src/flint/flintlib/functions/arith.pxd deleted file mode 100644 index 773ae7c8..00000000 --- a/src/flint/flintlib/functions/arith.pxd +++ /dev/null @@ -1,60 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_struct, fmpz_t, nmod_t, nn_ptr, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_poly_t, fmpq_struct, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mat_t, fmpz_poly_t - -# unknown type mpfr_t -# unknown type trig_prod_t - - -cdef extern from "flint/arith.h": - void _arith_harmonic_number(fmpz_t num, fmpz_t den, slong n) - void arith_harmonic_number(fmpq_t x, slong n) - void arith_stirling_number_1u(fmpz_t s, ulong n, ulong k) - void arith_stirling_number_1(fmpz_t s, ulong n, ulong k) - void arith_stirling_number_2(fmpz_t s, ulong n, ulong k) - void arith_stirling_number_1u_vec(fmpz_struct * row, ulong n, slong klen) - void arith_stirling_number_1_vec(fmpz_struct * row, ulong n, slong klen) - void arith_stirling_number_2_vec(fmpz_struct * row, ulong n, slong klen) - void arith_stirling_number_1u_vec_next(fmpz_struct * row, const fmpz_struct * prev, slong n, slong klen) - void arith_stirling_number_1_vec_next(fmpz_struct * row, const fmpz_struct * prev, slong n, slong klen) - void arith_stirling_number_2_vec_next(fmpz_struct * row, const fmpz_struct * prev, slong n, slong klen) - void arith_stirling_matrix_1u(fmpz_mat_t mat) - void arith_stirling_matrix_1(fmpz_mat_t mat) - void arith_stirling_matrix_2(fmpz_mat_t mat) - void arith_bell_number(fmpz_t b, ulong n) - void arith_bell_number_dobinski(fmpz_t res, ulong n) - void arith_bell_number_multi_mod(fmpz_t res, ulong n) - void arith_bell_number_vec(fmpz_struct * b, slong n) - void arith_bell_number_vec_recursive(fmpz_struct * b, slong n) - void arith_bell_number_vec_multi_mod(fmpz_struct * b, slong n) - ulong arith_bell_number_nmod(ulong n, nmod_t mod) - void arith_bell_number_nmod_vec(nn_ptr b, slong n, nmod_t mod) - void arith_bell_number_nmod_vec_recursive(nn_ptr b, slong n, nmod_t mod) - void arith_bell_number_nmod_vec_ogf(nn_ptr b, slong n, nmod_t mod) - int arith_bell_number_nmod_vec_series(nn_ptr b, slong n, nmod_t mod) - double arith_bell_number_size(ulong n) - void _arith_bernoulli_number(fmpz_t num, fmpz_t den, ulong n) - void arith_bernoulli_number(fmpq_t x, ulong n) - void _arith_bernoulli_number_vec(fmpz_struct * num, fmpz_struct * den, slong n) - void arith_bernoulli_number_vec(fmpq_struct * x, slong n) - void arith_bernoulli_number_denom(fmpz_t den, ulong n) - double arith_bernoulli_number_size(ulong n) - void arith_bernoulli_polynomial(fmpq_poly_t poly, ulong n) - void _arith_bernoulli_number_vec_recursive(fmpz_struct * num, fmpz_struct * den, slong n) - void _arith_bernoulli_number_vec_multi_mod(fmpz_struct * num, fmpz_struct * den, slong n) - void arith_euler_number(fmpz_t res, ulong n) - void arith_euler_number_vec(fmpz_struct * res, slong n) - double arith_euler_number_size(ulong n) - void arith_euler_polynomial(fmpq_poly_t poly, ulong n) - void arith_divisors(fmpz_poly_t res, const fmpz_t n) - void arith_ramanujan_tau(fmpz_t res, const fmpz_t n) - void arith_ramanujan_tau_series(fmpz_poly_t res, slong n) - void arith_landau_function_vec(fmpz_struct * res, slong len) - void arith_number_of_partitions_vec(fmpz_struct * res, slong len) - void arith_number_of_partitions_nmod_vec(nn_ptr res, slong len, nmod_t mod) - # void trig_prod_init(trig_prod_t prod) - # void arith_hrr_expsum_factored(trig_prod_t prod, ulong k, ulong n) - # void arith_number_of_partitions_mpfr(mpfr_t x, ulong n) - void arith_number_of_partitions(fmpz_t x, ulong n) - void arith_sum_of_squares(fmpz_t r, ulong k, const fmpz_t n) - void arith_sum_of_squares_vec(fmpz_struct * r, ulong k, slong n) diff --git a/src/flint/flintlib/functions/bernoulli.pxd b/src/flint/flintlib/functions/bernoulli.pxd deleted file mode 100644 index e39d1414..00000000 --- a/src/flint/flintlib/functions/bernoulli.pxd +++ /dev/null @@ -1,18 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_struct, fmpq_t - -# unknown type bernoulli_rev_t - - -cdef extern from "flint/bernoulli.h": - # void bernoulli_rev_init(bernoulli_rev_t iter, ulong n) - # void bernoulli_rev_next(fmpz_t numer, fmpz_t denom, bernoulli_rev_t iter) - # void bernoulli_rev_clear(bernoulli_rev_t iter) - void bernoulli_fmpq_vec_no_cache(fmpq_struct * res, ulong a, slong num) - void bernoulli_cache_compute(slong n) - slong bernoulli_bound_2exp_si(ulong n) - ulong bernoulli_mod_p_harvey(ulong n, ulong p) - void _bernoulli_fmpq_ui_zeta(fmpz_t num, fmpz_t den, ulong n) - void _bernoulli_fmpq_ui_multi_mod(fmpz_t num, fmpz_t den, ulong n, double alpha) - void _bernoulli_fmpq_ui(fmpz_t num, fmpz_t den, ulong n) - void bernoulli_fmpq_ui(fmpq_t b, ulong n) diff --git a/src/flint/flintlib/functions/compat.pxd b/src/flint/flintlib/functions/compat.pxd deleted file mode 100644 index c292df92..00000000 --- a/src/flint/flintlib/functions/compat.pxd +++ /dev/null @@ -1,17 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mpoly_ctx_t, fmpz_mod_mpoly_t - - -cdef extern from *: - """ - #if __FLINT_RELEASE < 30200 /* Flint < 3.2.0 */ - - #define compat_fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen(...) (void)0 - - #else - - #define compat_fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen(...) fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen(__VA_ARGS__) - - #endif - """ - void compat_fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const slong * c, const fmpz_mod_mpoly_ctx_t ctxB, const fmpz_mod_mpoly_ctx_t ctxAC) diff --git a/src/flint/flintlib/functions/dirichlet.pxd b/src/flint/flintlib/functions/dirichlet.pxd deleted file mode 100644 index 91fc97e2..00000000 --- a/src/flint/flintlib/functions/dirichlet.pxd +++ /dev/null @@ -1,46 +0,0 @@ -from flint.flintlib.types.dirichlet cimport dirichlet_char_t, dirichlet_group_t -from flint.flintlib.types.flint cimport slong, ulong - - - -cdef extern from "flint/dirichlet.h": - int dirichlet_group_init(dirichlet_group_t G, ulong q) - void dirichlet_subgroup_init(dirichlet_group_t H, const dirichlet_group_t G, ulong h) - void dirichlet_group_clear(dirichlet_group_t G) - ulong dirichlet_group_size(const dirichlet_group_t G) - ulong dirichlet_group_num_primitive(const dirichlet_group_t G) - void dirichlet_group_dlog_precompute(dirichlet_group_t G, ulong num) - void dirichlet_group_dlog_clear(dirichlet_group_t G) - void dirichlet_char_init(dirichlet_char_t chi, const dirichlet_group_t G) - void dirichlet_char_clear(dirichlet_char_t chi) - void dirichlet_char_print(const dirichlet_group_t G, const dirichlet_char_t chi) - void dirichlet_char_log(dirichlet_char_t x, const dirichlet_group_t G, ulong m) - ulong dirichlet_char_exp(const dirichlet_group_t G, const dirichlet_char_t x) - ulong _dirichlet_char_exp(dirichlet_char_t x, const dirichlet_group_t G) - void dirichlet_char_one(dirichlet_char_t x, const dirichlet_group_t G) - void dirichlet_char_first_primitive(dirichlet_char_t x, const dirichlet_group_t G) - void dirichlet_char_set(dirichlet_char_t x, const dirichlet_group_t G, const dirichlet_char_t y) - int dirichlet_char_next(dirichlet_char_t x, const dirichlet_group_t G) - int dirichlet_char_next_primitive(dirichlet_char_t x, const dirichlet_group_t G) - ulong dirichlet_index_char(const dirichlet_group_t G, const dirichlet_char_t x) - void dirichlet_char_index(dirichlet_char_t x, const dirichlet_group_t G, ulong j) - int dirichlet_char_eq(const dirichlet_char_t x, const dirichlet_char_t y) - int dirichlet_char_eq_deep(const dirichlet_group_t G, const dirichlet_char_t x, const dirichlet_char_t y) - int dirichlet_char_is_principal(const dirichlet_group_t G, const dirichlet_char_t chi) - ulong dirichlet_conductor_ui(const dirichlet_group_t G, ulong a) - ulong dirichlet_conductor_char(const dirichlet_group_t G, const dirichlet_char_t x) - int dirichlet_parity_ui(const dirichlet_group_t G, ulong a) - int dirichlet_parity_char(const dirichlet_group_t G, const dirichlet_char_t x) - ulong dirichlet_order_ui(const dirichlet_group_t G, ulong a) - ulong dirichlet_order_char(const dirichlet_group_t G, const dirichlet_char_t x) - int dirichlet_char_is_real(const dirichlet_group_t G, const dirichlet_char_t chi) - int dirichlet_char_is_primitive(const dirichlet_group_t G, const dirichlet_char_t chi) - ulong dirichlet_pairing(const dirichlet_group_t G, ulong m, ulong n) - ulong dirichlet_pairing_char(const dirichlet_group_t G, const dirichlet_char_t chi, const dirichlet_char_t psi) - ulong dirichlet_chi(const dirichlet_group_t G, const dirichlet_char_t chi, ulong n) - void dirichlet_chi_vec(ulong * v, const dirichlet_group_t G, const dirichlet_char_t chi, slong nv) - void dirichlet_chi_vec_order(ulong * v, const dirichlet_group_t G, const dirichlet_char_t chi, ulong order, slong nv) - void dirichlet_char_mul(dirichlet_char_t chi12, const dirichlet_group_t G, const dirichlet_char_t chi1, const dirichlet_char_t chi2) - void dirichlet_char_pow(dirichlet_char_t c, const dirichlet_group_t G, const dirichlet_char_t a, ulong n) - void dirichlet_char_lift(dirichlet_char_t chi_G, const dirichlet_group_t G, const dirichlet_char_t chi_H, const dirichlet_group_t H) - void dirichlet_char_lower(dirichlet_char_t chi_H, const dirichlet_group_t H, const dirichlet_char_t chi_G, const dirichlet_group_t G) diff --git a/src/flint/flintlib/functions/flint.pxd b/src/flint/flintlib/functions/flint.pxd deleted file mode 100644 index 72ad08e1..00000000 --- a/src/flint/flintlib/functions/flint.pxd +++ /dev/null @@ -1,48 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong - -# unknown type ... -# unknown type FILE -# unknown type flint_err_t -# unknown type int ( cmp) ( void -# unknown type size_t -# unknown type va_list -# unknown type va_list) -# unknown type void ( - -# .. macro:: __FLINT_VERSION -# .. macro:: __FLINT_RELEASE -# .. macro:: FLINT_VERSION -# .. macro:: FLINT_BITS -# .. macro:: FLINT_D_BITS -# .. macro:: FLINT_ABS(x) -# .. macro:: FLINT_UABS(x) -# .. macro:: FLINT_MIN(x, y) -# .. macro:: FLINT_SWAP(T, x, y) -# .. macro:: FLINT_SGN(x) -# .. macro:: UWORD_MIN - -cdef extern from "flint/flint.h": - # void * flint_malloc(size_t size) - # void * flint_realloc(void * ptr, size_t size) - # void * flint_calloc(size_t num, size_t size) - void flint_free(void * ptr) - void flint_rand_init(flint_rand_t state) - void flint_rand_clear(flint_rand_t state) - void flint_set_num_threads(int num_threads) - # int flint_get_num_threads(void) - int flint_set_num_workers(int num_workers) - void flint_reset_num_workers(int num_workers) - # int flint_printf(const char * format, ...) - # int flint_fprintf(FILE * fs, const char * format, ...) - # int flint_vprintf(const char * format, va_list vlist) - # int flint_vfprintf(FILE * fs, const char * format, va_list vlist) - # int flint_sprintf(char * s, const char * str, ...) - # int flint_scanf(const char * str, ...) - # int flint_fscanf(FILE * f, const char * str, ...) - # int flint_sscanf(const char * s, const char * str, ...) - # void flint_abort(void) - # void flint_throw(flint_err_t exc, const char * msg, ...) - # void flint_set_abort(void (* func)(void)) - # void flint_set_throw(void (* func)(flint_err_t, const char *, va_list)) - # void flint_merge_sort(void * buf, slong len, slong size, int (* cmp) (const void *, const void *, void *), void * data) - # void flint_sort(void * buf, slong len, slong size, int (* cmp) (const void *, const void *, void *), void * data) diff --git a/src/flint/flintlib/functions/fmpq.pxd b/src/flint/flintlib/functions/fmpq.pxd deleted file mode 100644 index 04e7d369..00000000 --- a/src/flint/flintlib/functions/fmpq.pxd +++ /dev/null @@ -1,133 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t - -# unknown type FILE -# unknown type mpfr_rnd_t -# unknown type mpfr_t -# unknown type mpq_t -# unknown type mpz_t - - -cdef extern from "flint/fmpq.h": - fmpz_struct * fmpq_numref(const fmpq_t x) - fmpz_struct * fmpq_denref(const fmpq_t x) - void fmpq_init(fmpq_t x) - void fmpq_clear(fmpq_t x) - void fmpq_canonicalise(fmpq_t res) - void _fmpq_canonicalise(fmpz_t num, fmpz_t den) - int fmpq_is_canonical(const fmpq_t x) - int _fmpq_is_canonical(const fmpz_t num, const fmpz_t den) - void fmpq_set(fmpq_t dest, const fmpq_t src) - void fmpq_swap(fmpq_t op1, fmpq_t op2) - void fmpq_neg(fmpq_t dest, const fmpq_t src) - void fmpq_abs(fmpq_t dest, const fmpq_t src) - void fmpq_zero(fmpq_t res) - void fmpq_one(fmpq_t res) - int fmpq_is_zero(const fmpq_t res) - int fmpq_is_one(const fmpq_t res) - int fmpq_is_pm1(const fmpq_t res) - int fmpq_equal(const fmpq_t x, const fmpq_t y) - int fmpq_equal_fmpz(const fmpq_t x, const fmpz_t y) - int fmpq_equal_si(fmpq_t x, slong y) - int fmpq_equal_ui(fmpq_t x, ulong y) - int fmpq_sgn(const fmpq_t x) - int fmpq_cmp(const fmpq_t x, const fmpq_t y) - int fmpq_cmp_fmpz(const fmpq_t x, const fmpz_t y) - int fmpq_cmp_si(const fmpq_t x, slong y) - int fmpq_cmp_ui(const fmpq_t x, ulong y) - void fmpq_height(fmpz_t height, const fmpq_t x) - flint_bitcnt_t fmpq_height_bits(const fmpq_t x) - void fmpq_set_fmpz_frac(fmpq_t res, const fmpz_t p, const fmpz_t q) - # void fmpq_get_mpz_frac(mpz_t a, mpz_t b, fmpq_t c) - void fmpq_set_si(fmpq_t res, slong p, ulong q) - void _fmpq_set_si(fmpz_t rnum, fmpz_t rden, slong p, ulong q) - void fmpq_set_ui(fmpq_t res, ulong p, ulong q) - void _fmpq_set_ui(fmpz_t rnum, fmpz_t rden, ulong p, ulong q) - # void fmpq_set_mpq(fmpq_t dest, const mpq_t src) - int fmpq_set_str(fmpq_t dest, const char * s, int base) - double fmpq_get_d(const fmpq_t f) - # void fmpq_get_mpq(mpq_t dest, const fmpq_t src) - # int fmpq_get_mpfr(mpfr_t dest, const fmpq_t src, mpfr_rnd_t rnd) - char * _fmpq_get_str(char * str, int b, const fmpz_t num, const fmpz_t den) - char * fmpq_get_str(char * str, int b, const fmpq_t x) - # void flint_mpq_init_set_readonly(mpq_t z, const fmpq_t f) - # void flint_mpq_clear_readonly(mpq_t z) - # void fmpq_init_set_readonly(fmpq_t f, const mpq_t z) - void fmpq_clear_readonly(fmpq_t f) - # int fmpq_fprint(FILE * file, const fmpq_t x) - # int _fmpq_fprint(FILE * file, const fmpz_t num, const fmpz_t den) - int fmpq_print(const fmpq_t x) - int _fmpq_print(const fmpz_t num, const fmpz_t den) - void fmpq_randtest(fmpq_t res, flint_rand_t state, flint_bitcnt_t bits) - void _fmpq_randtest(fmpz_t num, fmpz_t den, flint_rand_t state, flint_bitcnt_t bits) - void fmpq_randtest_not_zero(fmpq_t res, flint_rand_t state, flint_bitcnt_t bits) - void fmpq_randbits(fmpq_t res, flint_rand_t state, flint_bitcnt_t bits) - void _fmpq_randbits(fmpz_t num, fmpz_t den, flint_rand_t state, flint_bitcnt_t bits) - void fmpq_add(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void fmpq_sub(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void fmpq_mul(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void fmpq_div(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void _fmpq_add(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) - void _fmpq_sub(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) - void _fmpq_mul(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) - void _fmpq_div(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) - void _fmpq_add_si(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, slong r) - void _fmpq_sub_si(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, slong r) - void _fmpq_add_ui(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, ulong r) - void _fmpq_sub_ui(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, ulong r) - void _fmpq_add_fmpz(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, const fmpz_t r) - void _fmpq_sub_fmpz(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, const fmpz_t r) - void fmpq_add_si(fmpq_t res, const fmpq_t op1, slong c) - void fmpq_sub_si(fmpq_t res, const fmpq_t op1, slong c) - void fmpq_add_ui(fmpq_t res, const fmpq_t op1, ulong c) - void fmpq_sub_ui(fmpq_t res, const fmpq_t op1, ulong c) - void fmpq_add_fmpz(fmpq_t res, const fmpq_t op1, const fmpz_t c) - void fmpq_sub_fmpz(fmpq_t res, const fmpq_t op1, const fmpz_t c) - void _fmpq_mul_si(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, slong r) - void fmpq_mul_si(fmpq_t res, const fmpq_t op1, slong c) - void _fmpq_mul_ui(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, ulong r) - void fmpq_mul_ui(fmpq_t res, const fmpq_t op1, ulong c) - void fmpq_addmul(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void fmpq_submul(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void _fmpq_addmul(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) - void _fmpq_submul(fmpz_t rnum, fmpz_t rden, const fmpz_t op1num, const fmpz_t op1den, const fmpz_t op2num, const fmpz_t op2den) - void fmpq_inv(fmpq_t dest, const fmpq_t src) - void _fmpq_pow_si(fmpz_t rnum, fmpz_t rden, const fmpz_t opnum, const fmpz_t opden, slong e) - void fmpq_pow_si(fmpq_t res, const fmpq_t op, slong e) - int fmpq_pow_fmpz(fmpq_t a, const fmpq_t b, const fmpz_t e) - void fmpq_mul_fmpz(fmpq_t res, const fmpq_t op, const fmpz_t x) - void fmpq_div_fmpz(fmpq_t res, const fmpq_t op, const fmpz_t x) - void fmpq_mul_2exp(fmpq_t res, const fmpq_t x, flint_bitcnt_t exp) - void fmpq_div_2exp(fmpq_t res, const fmpq_t x, flint_bitcnt_t exp) - void _fmpq_gcd(fmpz_t rnum, fmpz_t rden, const fmpz_t p, const fmpz_t q, const fmpz_t r, const fmpz_t s) - void fmpq_gcd(fmpq_t res, const fmpq_t op1, const fmpq_t op2) - void _fmpq_gcd_cofactors(fmpz_t gnum, fmpz_t gden, fmpz_t abar, fmpz_t bbar, const fmpz_t anum, const fmpz_t aden, const fmpz_t bnum, const fmpz_t bden) - void fmpq_gcd_cofactors(fmpq_t g, fmpz_t abar, fmpz_t bbar, const fmpq_t a, const fmpq_t b) - void _fmpq_add_small(fmpz_t rnum, fmpz_t rden, slong p1, ulong q1, slong p2, ulong q2) - void _fmpq_mul_small(fmpz_t rnum, fmpz_t rden, slong p1, ulong q1, slong p2, ulong q2) - int _fmpq_mod_fmpz(fmpz_t res, const fmpz_t num, const fmpz_t den, const fmpz_t mod) - int fmpq_mod_fmpz(fmpz_t res, const fmpq_t x, const fmpz_t mod) - int _fmpq_reconstruct_fmpz_2_naive(fmpz_t n, fmpz_t d, const fmpz_t a, const fmpz_t m, const fmpz_t N, const fmpz_t D) - int _fmpq_reconstruct_fmpz_2(fmpz_t n, fmpz_t d, const fmpz_t a, const fmpz_t m, const fmpz_t N, const fmpz_t D) - int fmpq_reconstruct_fmpz_2(fmpq_t res, const fmpz_t a, const fmpz_t m, const fmpz_t N, const fmpz_t D) - int _fmpq_reconstruct_fmpz(fmpz_t n, fmpz_t d, const fmpz_t a, const fmpz_t m) - int fmpq_reconstruct_fmpz(fmpq_t res, const fmpz_t a, const fmpz_t m) - void _fmpq_next_minimal(fmpz_t rnum, fmpz_t rden, const fmpz_t num, const fmpz_t den) - void fmpq_next_minimal(fmpq_t res, const fmpq_t x) - void _fmpq_next_signed_minimal(fmpz_t rnum, fmpz_t rden, const fmpz_t num, const fmpz_t den) - void fmpq_next_signed_minimal(fmpq_t res, const fmpq_t x) - void _fmpq_next_calkin_wilf(fmpz_t rnum, fmpz_t rden, const fmpz_t num, const fmpz_t den) - void fmpq_next_calkin_wilf(fmpq_t res, const fmpq_t x) - void _fmpq_next_signed_calkin_wilf(fmpz_t rnum, fmpz_t rden, const fmpz_t num, const fmpz_t den) - void fmpq_next_signed_calkin_wilf(fmpq_t res, const fmpq_t x) - void fmpq_farey_neighbors(fmpq_t l, fmpq_t r, const fmpq_t x, const fmpz_t Q) - void _fmpq_simplest_between(fmpz_t x_num, fmpz_t x_den, const fmpz_t l_num, const fmpz_t l_den, const fmpz_t r_num, const fmpz_t r_den) - void fmpq_simplest_between(fmpq_t x, const fmpq_t l, const fmpq_t r) - slong fmpq_get_cfrac(fmpz_struct * c, fmpq_t rem, const fmpq_t x, slong n) - slong fmpq_get_cfrac_naive(fmpz_struct * c, fmpq_t rem, const fmpq_t x, slong n) - void fmpq_set_cfrac(fmpq_t x, const fmpz_struct * c, slong n) - slong fmpq_cfrac_bound(const fmpq_t x) - void _fmpq_harmonic_ui(fmpz_t num, fmpz_t den, ulong n) - void fmpq_harmonic_ui(fmpq_t x, ulong n) - void fmpq_dedekind_sum(fmpq_t s, const fmpz_t h, const fmpz_t k) - void fmpq_dedekind_sum_naive(fmpq_t s, const fmpz_t h, const fmpz_t k) diff --git a/src/flint/flintlib/functions/fmpq_mat.pxd b/src/flint/flintlib/functions/fmpq_mat.pxd deleted file mode 100644 index 28eccce8..00000000 --- a/src/flint/flintlib/functions/fmpq_mat.pxd +++ /dev/null @@ -1,93 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong -from flint.flintlib.types.fmpq cimport fmpq_mat_t, fmpq_poly_t, fmpq_struct, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mat_t - - - -cdef extern from "flint/fmpq_mat.h": - void fmpq_mat_init(fmpq_mat_t mat, slong rows, slong cols) - void fmpq_mat_init_set(fmpq_mat_t mat1, const fmpq_mat_t mat2) - void fmpq_mat_clear(fmpq_mat_t mat) - void fmpq_mat_swap(fmpq_mat_t mat1, fmpq_mat_t mat2) - void fmpq_mat_swap_entrywise(fmpq_mat_t mat1, fmpq_mat_t mat2) - fmpq_struct * fmpq_mat_entry(const fmpq_mat_t mat, slong i, slong j) - fmpz_struct * fmpq_mat_entry_num(const fmpq_mat_t mat, slong i, slong j) - fmpz_struct * fmpq_mat_entry_den(const fmpq_mat_t mat, slong i, slong j) - slong fmpq_mat_nrows(const fmpq_mat_t mat) - slong fmpq_mat_ncols(const fmpq_mat_t mat) - void fmpq_mat_set(fmpq_mat_t dest, const fmpq_mat_t src) - void fmpq_mat_zero(fmpq_mat_t mat) - void fmpq_mat_one(fmpq_mat_t mat) - void fmpq_mat_transpose(fmpq_mat_t rop, const fmpq_mat_t op) - void fmpq_mat_swap_rows(fmpq_mat_t mat, slong * perm, slong r, slong s) - void fmpq_mat_swap_cols(fmpq_mat_t mat, slong * perm, slong r, slong s) - void fmpq_mat_invert_rows(fmpq_mat_t mat, slong * perm) - void fmpq_mat_invert_cols(fmpq_mat_t mat, slong * perm) - void fmpq_mat_add(fmpq_mat_t mat, const fmpq_mat_t mat1, const fmpq_mat_t mat2) - void fmpq_mat_sub(fmpq_mat_t mat, const fmpq_mat_t mat1, const fmpq_mat_t mat2) - void fmpq_mat_neg(fmpq_mat_t rop, const fmpq_mat_t op) - void fmpq_mat_scalar_mul_fmpq(fmpq_mat_t rop, const fmpq_mat_t op, const fmpq_t x) - void fmpq_mat_scalar_mul_fmpz(fmpq_mat_t rop, const fmpq_mat_t op, const fmpz_t x) - void fmpq_mat_scalar_div_fmpz(fmpq_mat_t rop, const fmpq_mat_t op, const fmpz_t x) - void fmpq_mat_print(const fmpq_mat_t mat) - void fmpq_mat_randbits(fmpq_mat_t mat, flint_rand_t state, flint_bitcnt_t bits) - void fmpq_mat_randtest(fmpq_mat_t mat, flint_rand_t state, flint_bitcnt_t bits) - void fmpq_mat_window_init(fmpq_mat_t window, const fmpq_mat_t mat, slong r1, slong c1, slong r2, slong c2) - void fmpq_mat_window_clear(fmpq_mat_t window) - void fmpq_mat_concat_vertical(fmpq_mat_t res, const fmpq_mat_t mat1, const fmpq_mat_t mat2) - void fmpq_mat_concat_horizontal(fmpq_mat_t res, const fmpq_mat_t mat1, const fmpq_mat_t mat2) - void fmpq_mat_hilbert_matrix(fmpq_mat_t mat) - int fmpq_mat_equal(const fmpq_mat_t mat1, const fmpq_mat_t mat2) - int fmpq_mat_is_integral(const fmpq_mat_t mat) - int fmpq_mat_is_zero(const fmpq_mat_t mat) - int fmpq_mat_is_one(const fmpq_mat_t mat) - int fmpq_mat_is_empty(const fmpq_mat_t mat) - int fmpq_mat_is_square(const fmpq_mat_t mat) - int fmpq_mat_get_fmpz_mat(fmpz_mat_t dest, const fmpq_mat_t mat) - void fmpq_mat_get_fmpz_mat_entrywise(fmpz_mat_t num, fmpz_mat_t den, const fmpq_mat_t mat) - void fmpq_mat_get_fmpz_mat_matwise(fmpz_mat_t num, fmpz_t den, const fmpq_mat_t mat) - void fmpq_mat_get_fmpz_mat_rowwise(fmpz_mat_t num, fmpz_struct * den, const fmpq_mat_t mat) - void fmpq_mat_get_fmpz_mat_rowwise_2(fmpz_mat_t num, fmpz_mat_t num2, fmpz_struct * den, const fmpq_mat_t mat, const fmpq_mat_t mat2) - void fmpq_mat_get_fmpz_mat_colwise(fmpz_mat_t num, fmpz_struct * den, const fmpq_mat_t mat) - void fmpq_mat_set_fmpz_mat(fmpq_mat_t dest, const fmpz_mat_t src) - void fmpq_mat_set_fmpz_mat_div_fmpz(fmpq_mat_t mat, const fmpz_mat_t num, const fmpz_t den) - void fmpq_mat_get_fmpz_mat_mod_fmpz(fmpz_mat_t dest, const fmpq_mat_t mat, const fmpz_t mod) - int fmpq_mat_set_fmpz_mat_mod_fmpz(fmpq_mat_t X, const fmpz_mat_t Xmod, const fmpz_t mod) - void fmpq_mat_mul_direct(fmpq_mat_t C, const fmpq_mat_t A, const fmpq_mat_t B) - void fmpq_mat_mul_cleared(fmpq_mat_t C, const fmpq_mat_t A, const fmpq_mat_t B) - void fmpq_mat_mul(fmpq_mat_t C, const fmpq_mat_t A, const fmpq_mat_t B) - void fmpq_mat_mul_fmpz_mat(fmpq_mat_t C, const fmpq_mat_t A, const fmpz_mat_t B) - void fmpq_mat_mul_r_fmpz_mat(fmpq_mat_t C, const fmpz_mat_t A, const fmpq_mat_t B) - void fmpq_mat_mul_fmpq_vec(fmpq_struct * c, const fmpq_mat_t A, const fmpq_struct * b, slong blen) - void fmpq_mat_mul_fmpz_vec(fmpq_struct * c, const fmpq_mat_t A, const fmpz_struct * b, slong blen) - void fmpq_mat_mul_fmpq_vec_ptr(fmpq_struct * const * c, const fmpq_mat_t A, const fmpq_struct * const * b, slong blen) - void fmpq_mat_mul_fmpz_vec_ptr(fmpq_struct * const * c, const fmpq_mat_t A, const fmpz_struct * const * b, slong blen) - void fmpq_mat_fmpq_vec_mul(fmpq_struct * c, const fmpq_struct * a, slong alen, const fmpq_mat_t B) - void fmpq_mat_fmpz_vec_mul(fmpq_struct * c, const fmpz_struct * a, slong alen, const fmpq_mat_t B) - void fmpq_mat_fmpq_vec_mul_ptr(fmpq_struct * const * c, const fmpq_struct * const * a, slong alen, const fmpq_mat_t B) - void fmpq_mat_fmpz_vec_mul_ptr(fmpq_struct * const * c, const fmpz_struct * const * a, slong alen, const fmpq_mat_t B) - void fmpq_mat_kronecker_product(fmpq_mat_t C, const fmpq_mat_t A, const fmpq_mat_t B) - void fmpq_mat_trace(fmpq_t trace, const fmpq_mat_t mat) - void fmpq_mat_det(fmpq_t det, const fmpq_mat_t mat) - int fmpq_mat_solve_fraction_free(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_solve_dixon(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_solve_multi_mod(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_solve(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_solve_fmpz_mat_fraction_free(fmpq_mat_t X, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpq_mat_solve_fmpz_mat_dixon(fmpq_mat_t X, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpq_mat_solve_fmpz_mat_multi_mod(fmpq_mat_t X, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpq_mat_solve_fmpz_mat(fmpq_mat_t X, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpq_mat_can_solve_multi_mod(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_can_solve_fraction_free(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_can_solve(fmpq_mat_t X, const fmpq_mat_t A, const fmpq_mat_t B) - int fmpq_mat_inv(fmpq_mat_t B, const fmpq_mat_t A) - int fmpq_mat_pivot(slong * perm, fmpq_mat_t mat, slong r, slong c) - slong fmpq_mat_rref_classical(fmpq_mat_t B, const fmpq_mat_t A) - slong fmpq_mat_rref_fraction_free(fmpq_mat_t B, const fmpq_mat_t A) - slong fmpq_mat_rref(fmpq_mat_t B, const fmpq_mat_t A) - void fmpq_mat_gso(fmpq_mat_t B, const fmpq_mat_t A) - void fmpq_mat_similarity(fmpq_mat_t A, slong r, fmpq_t d) - void _fmpq_mat_charpoly(fmpz_struct * coeffs, fmpz_t den, const fmpq_mat_t mat) - void fmpq_mat_charpoly(fmpq_poly_t pol, const fmpq_mat_t mat) - slong _fmpq_mat_minpoly(fmpz_struct * coeffs, fmpz_t den, const fmpq_mat_t mat) - void fmpq_mat_minpoly(fmpq_poly_t pol, const fmpq_mat_t mat) diff --git a/src/flint/flintlib/functions/fmpq_mpoly.pxd b/src/flint/flintlib/functions/fmpq_mpoly.pxd deleted file mode 100644 index 1dc1d0ad..00000000 --- a/src/flint/flintlib/functions/fmpq_mpoly.pxd +++ /dev/null @@ -1,158 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_mpoly_ctx_t, fmpq_mpoly_struct, fmpq_mpoly_t, fmpq_poly_struct, fmpq_poly_t, fmpq_struct, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mpoly_struct -from flint.flintlib.types.mpoly cimport ordering_t - -# unknown type FILE -# unknown type fmpq_mpoly_univar_t - - -cdef extern from "flint/fmpq_mpoly.h": - void fmpq_mpoly_ctx_init(fmpq_mpoly_ctx_t ctx, slong nvars, const ordering_t ord) - slong fmpq_mpoly_ctx_nvars(const fmpq_mpoly_ctx_t ctx) - ordering_t fmpq_mpoly_ctx_ord(const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_ctx_clear(fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_init(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_init2(fmpq_mpoly_t A, slong alloc, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_init3(fmpq_mpoly_t A, slong alloc, flint_bitcnt_t bits, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_fit_length(fmpq_mpoly_t A, slong len, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_fit_bits(fmpq_mpoly_t A, flint_bitcnt_t bits, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_realloc(fmpq_mpoly_t A, slong alloc, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_clear(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - char * fmpq_mpoly_get_str_pretty(const fmpq_mpoly_t A, const char ** x, const fmpq_mpoly_ctx_t ctx) - # int fmpq_mpoly_fprint_pretty(FILE * file, const fmpq_mpoly_t A, const char ** x, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_print_pretty(const fmpq_mpoly_t A, const char ** x, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_set_str_pretty(fmpq_mpoly_t A, const char * str, const char ** x, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_gen(fmpq_mpoly_t A, slong var, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_is_gen(const fmpq_mpoly_t A, slong var, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_equal(const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_swap(fmpq_mpoly_t A, fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_is_fmpq(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_fmpq(fmpq_t c, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_fmpq(fmpq_mpoly_t A, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_fmpz(fmpq_mpoly_t A, const fmpz_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_ui(fmpq_mpoly_t A, ulong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_si(fmpq_mpoly_t A, slong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_zero(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_one(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_equal_fmpq(const fmpq_mpoly_t A, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_equal_fmpz(const fmpq_mpoly_t A, const fmpz_t c, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_equal_ui(const fmpq_mpoly_t A, ulong c, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_equal_si(const fmpq_mpoly_t A, slong c, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_is_zero(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_is_one(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_degrees_fit_si(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_degrees_fmpz(fmpz_struct ** degs, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_degrees_si(slong * degs, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_degree_fmpz(fmpz_t deg, const fmpq_mpoly_t A, slong var, const fmpq_mpoly_ctx_t ctx) - slong fmpq_mpoly_degree_si(const fmpq_mpoly_t A, slong var, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_total_degree_fits_si(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_total_degree_fmpz(fmpz_t tdeg, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - slong fmpq_mpoly_total_degree_si(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_used_vars(int * used, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_denominator(fmpz_t d, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_coeff_fmpq_monomial(fmpq_t c, const fmpq_mpoly_t A, const fmpq_mpoly_t M, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_coeff_fmpq_monomial(fmpq_mpoly_t A, const fmpq_t c, const fmpq_mpoly_t M, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_coeff_fmpq_fmpz(fmpq_t c, const fmpq_mpoly_t A, fmpz_struct * const * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_coeff_fmpq_ui(fmpq_t c, const fmpq_mpoly_t A, const ulong * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_coeff_fmpq_fmpz(fmpq_mpoly_t A, const fmpq_t c, fmpz_struct * const * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_coeff_fmpq_ui(fmpq_mpoly_t A, const fmpq_t c, const ulong * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_coeff_vars_ui(fmpq_mpoly_t C, const fmpq_mpoly_t A, const slong * vars, const ulong * exps, slong length, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_cmp(const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - fmpq_struct * fmpq_mpoly_content_ref(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - fmpz_mpoly_struct * fmpq_mpoly_zpoly_ref(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - fmpz_struct * fmpq_mpoly_zpoly_term_coeff_ref(fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_is_canonical(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - slong fmpq_mpoly_length(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_resize(fmpq_mpoly_t A, slong new_length, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_term_coeff_fmpq(fmpq_t c, const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_term_coeff_fmpq(fmpq_mpoly_t A, slong i, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_term_exp_fits_si(const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_term_exp_fits_ui(const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_term_exp_fmpz(fmpz_struct ** exps, const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_term_exp_ui(ulong * exps, const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_term_exp_si(slong * exps, const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - ulong fmpq_mpoly_get_term_var_exp_ui(const fmpq_mpoly_t A, slong i, slong var, const fmpq_mpoly_ctx_t ctx) - slong fmpq_mpoly_get_term_var_exp_si(const fmpq_mpoly_t A, slong i, slong var, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_term_exp_fmpz(fmpq_mpoly_t A, slong i, fmpz_struct * const * exps, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_set_term_exp_ui(fmpq_mpoly_t A, slong i, const ulong * exps, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_term(fmpq_mpoly_t M, const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_get_term_monomial(fmpq_mpoly_t M, const fmpq_mpoly_t A, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_fmpq_fmpz(fmpq_mpoly_t A, const fmpq_t c, fmpz_struct * const * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_fmpq_ffmpz(fmpq_mpoly_t A, const fmpq_t c, const fmpz_struct * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_fmpz_fmpz(fmpq_mpoly_t A, const fmpz_t c, fmpz_struct * const * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_fmpz_ffmpz(fmpq_mpoly_t A, const fmpz_t c, const fmpz_struct * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_ui_fmpz(fmpq_mpoly_t A, ulong c, fmpz_struct * const * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_ui_ffmpz(fmpq_mpoly_t A, ulong c, const fmpz_struct * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_si_fmpz(fmpq_mpoly_t A, slong c, fmpz_struct * const * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_si_ffmpz(fmpq_mpoly_t A, slong c, const fmpz_struct * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_fmpq_ui(fmpq_mpoly_t A, const fmpq_t c, const ulong * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_fmpz_ui(fmpq_mpoly_t A, const fmpz_t c, const ulong * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_ui_ui(fmpq_mpoly_t A, ulong c, const ulong * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_push_term_si_ui(fmpq_mpoly_t A, slong c, const ulong * exp, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_reduce(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_sort_terms(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_combine_like_terms(fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_reverse(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_randtest_bound(fmpq_mpoly_t A, flint_rand_t state, slong length, ulong coeff_bits, ulong exp_bound, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_randtest_bounds(fmpq_mpoly_t A, flint_rand_t state, slong length, ulong coeff_bits, ulong * exp_bounds, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_randtest_bits(fmpq_mpoly_t A, flint_rand_t state, slong length, ulong coeff_bits, ulong exp_bits, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_add_fmpq(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_add_fmpz(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpz_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_add_ui(fmpq_mpoly_t A, const fmpq_mpoly_t B, ulong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_add_si(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_sub_fmpq(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_sub_fmpz(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpz_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_sub_ui(fmpq_mpoly_t A, const fmpq_mpoly_t B, ulong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_sub_si(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_add(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_t C, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_sub(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_t C, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_neg(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_mul_fmpq(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_mul_fmpz(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpz_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_mul_ui(fmpq_mpoly_t A, const fmpq_mpoly_t B, ulong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_mul_si(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_div_fmpq(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_div_fmpz(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpz_t c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_div_ui(fmpq_mpoly_t A, const fmpq_mpoly_t B, ulong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_scalar_div_si(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong c, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_make_monic(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_derivative(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong var, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_integral(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong var, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_evaluate_all_fmpq(fmpq_t ev, const fmpq_mpoly_t A, fmpq_struct * const * vals, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_evaluate_one_fmpq(fmpq_mpoly_t A, const fmpq_mpoly_t B, slong var, const fmpq_t val, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_compose_fmpq_poly(fmpq_poly_t A, const fmpq_mpoly_t B, fmpq_poly_struct * const * C, const fmpq_mpoly_ctx_t ctxB) - int fmpq_mpoly_compose_fmpq_mpoly(fmpq_mpoly_t A, const fmpq_mpoly_t B, fmpq_mpoly_struct * const * C, const fmpq_mpoly_ctx_t ctxB, const fmpq_mpoly_ctx_t ctxAC) - void fmpq_mpoly_compose_fmpq_mpoly_gen(fmpq_mpoly_t A, const fmpq_mpoly_t B, const slong * c, const fmpq_mpoly_ctx_t ctxB, const fmpq_mpoly_ctx_t ctxAC) - void fmpq_mpoly_mul(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_t C, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_pow_fmpz(fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpz_t k, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_pow_ui(fmpq_mpoly_t A, const fmpq_mpoly_t B, ulong k, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_divides(fmpq_mpoly_t Q, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_div(fmpq_mpoly_t Q, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_divrem(fmpq_mpoly_t Q, fmpq_mpoly_t R, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_divrem_ideal(fmpq_mpoly_struct ** Q, fmpq_mpoly_t R, const fmpq_mpoly_t A, fmpq_mpoly_struct * const * B, slong len, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_content(fmpq_t g, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_term_content(fmpq_mpoly_t M, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_content_vars(fmpq_mpoly_t g, const fmpq_mpoly_t A, slong * vars, slong vars_length, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd(fmpq_mpoly_t G, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd_cofactors(fmpq_mpoly_t G, fmpq_mpoly_t Abar, fmpq_mpoly_t Bbar, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd_brown(fmpq_mpoly_t G, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd_hensel(fmpq_mpoly_t G, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd_subresultant(fmpq_mpoly_t G, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd_zippel(fmpq_mpoly_t G, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_gcd_zippel2(fmpq_mpoly_t G, const fmpq_mpoly_t A, const fmpq_mpoly_t B, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_resultant(fmpq_mpoly_t R, const fmpq_mpoly_t A, const fmpq_mpoly_t B, slong var, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_discriminant(fmpq_mpoly_t D, const fmpq_mpoly_t A, slong var, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_sqrt(fmpq_mpoly_t Q, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_is_square(const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_univar_init(fmpq_mpoly_univar_t A, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_univar_clear(fmpq_mpoly_univar_t A, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_univar_swap(fmpq_mpoly_univar_t A, fmpq_mpoly_univar_t B, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_to_univar(fmpq_mpoly_univar_t A, const fmpq_mpoly_t B, slong var, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_from_univar(fmpq_mpoly_t A, const fmpq_mpoly_univar_t B, slong var, const fmpq_mpoly_ctx_t ctx) - # int fmpq_mpoly_univar_degree_fits_si(const fmpq_mpoly_univar_t A, const fmpq_mpoly_ctx_t ctx) - # slong fmpq_mpoly_univar_length(const fmpq_mpoly_univar_t A, const fmpq_mpoly_ctx_t ctx) - # slong fmpq_mpoly_univar_get_term_exp_si(fmpq_mpoly_univar_t A, slong i, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_univar_get_term_coeff(fmpq_mpoly_t c, const fmpq_mpoly_univar_t A, slong i, const fmpq_mpoly_ctx_t ctx) - # void fmpq_mpoly_univar_swap_term_coeff(fmpq_mpoly_t c, fmpq_mpoly_univar_t A, slong i, const fmpq_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpq_mpoly_factor.pxd b/src/flint/flintlib/functions/fmpq_mpoly_factor.pxd deleted file mode 100644 index e3c68f30..00000000 --- a/src/flint/flintlib/functions/fmpq_mpoly_factor.pxd +++ /dev/null @@ -1,18 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.fmpq cimport fmpq_mpoly_ctx_t, fmpq_mpoly_factor_t, fmpq_mpoly_t, fmpq_t - - - -cdef extern from "flint/fmpq_mpoly_factor.h": - void fmpq_mpoly_factor_init(fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_factor_clear(fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - slong fmpq_mpoly_factor_length(const fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_factor_get_constant_fmpq(fmpq_t c, const fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_factor_get_base(fmpq_mpoly_t B, const fmpq_mpoly_factor_t f, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_factor_swap_base(fmpq_mpoly_t B, fmpq_mpoly_factor_t f, slong i, const fmpq_mpoly_ctx_t ctx) - slong fmpq_mpoly_factor_get_exp_si(fmpq_mpoly_factor_t f, slong i, const fmpq_mpoly_ctx_t ctx) - void fmpq_mpoly_factor_sort(fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_factor_make_monic(fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_factor_make_integral(fmpq_mpoly_factor_t f, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_factor_squarefree(fmpq_mpoly_factor_t f, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) - int fmpq_mpoly_factor(fmpq_mpoly_factor_t f, const fmpq_mpoly_t A, const fmpq_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpq_poly.pxd b/src/flint/flintlib/functions/fmpq_poly.pxd deleted file mode 100644 index 93b19ff1..00000000 --- a/src/flint/flintlib/functions/fmpq_poly.pxd +++ /dev/null @@ -1,234 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_poly_struct, fmpq_poly_t, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_poly_t, fmpz_preinvn_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE -# unknown type fmpq_poly_powers_precomp_t - - -cdef extern from "flint/fmpq_poly.h": - void fmpq_poly_init(fmpq_poly_t poly) - void fmpq_poly_init2(fmpq_poly_t poly, slong alloc) - void fmpq_poly_realloc(fmpq_poly_t poly, slong alloc) - void fmpq_poly_fit_length(fmpq_poly_t poly, slong len) - void _fmpq_poly_set_length(fmpq_poly_t poly, slong len) - void fmpq_poly_clear(fmpq_poly_t poly) - void _fmpq_poly_normalise(fmpq_poly_t poly) - void _fmpq_poly_canonicalise(fmpz_struct * poly, fmpz_t den, slong len) - void fmpq_poly_canonicalise(fmpq_poly_t poly) - int _fmpq_poly_is_canonical(const fmpz_struct * poly, const fmpz_t den, slong len) - int fmpq_poly_is_canonical(const fmpq_poly_t poly) - slong fmpq_poly_degree(const fmpq_poly_t poly) - slong fmpq_poly_length(const fmpq_poly_t poly) - fmpz_struct * fmpq_poly_numref(fmpq_poly_t poly) - fmpz_t fmpq_poly_denref(fmpq_poly_t poly) - void fmpq_poly_get_numerator(fmpz_poly_t res, const fmpq_poly_t poly) - void fmpq_poly_get_denominator(fmpz_t den, const fmpq_poly_t poly) - void fmpq_poly_randtest(fmpq_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpq_poly_randtest_unsigned(fmpq_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpq_poly_randtest_not_zero(fmpq_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpq_poly_set(fmpq_poly_t poly1, const fmpq_poly_t poly2) - void fmpq_poly_set_si(fmpq_poly_t poly, slong x) - void fmpq_poly_set_ui(fmpq_poly_t poly, ulong x) - void fmpq_poly_set_fmpz(fmpq_poly_t poly, const fmpz_t x) - void fmpq_poly_set_fmpq(fmpq_poly_t poly, const fmpq_t x) - void fmpq_poly_set_fmpz_poly(fmpq_poly_t rop, const fmpz_poly_t op) - void fmpq_poly_set_nmod_poly(fmpq_poly_t rop, const nmod_poly_t op) - void fmpq_poly_get_nmod_poly(nmod_poly_t rop, const fmpq_poly_t op) - void fmpq_poly_get_nmod_poly_den(nmod_poly_t rop, const fmpq_poly_t op, int den) - int _fmpq_poly_set_str(fmpz_struct * poly, fmpz_t den, const char * str, slong len) - int fmpq_poly_set_str(fmpq_poly_t poly, const char * str) - char * fmpq_poly_get_str(const fmpq_poly_t poly) - char * fmpq_poly_get_str_pretty(const fmpq_poly_t poly, const char * var) - void fmpq_poly_zero(fmpq_poly_t poly) - void fmpq_poly_one(fmpq_poly_t poly) - void fmpq_poly_neg(fmpq_poly_t poly1, const fmpq_poly_t poly2) - void fmpq_poly_inv(fmpq_poly_t poly1, const fmpq_poly_t poly2) - void fmpq_poly_swap(fmpq_poly_t poly1, fmpq_poly_t poly2) - void fmpq_poly_truncate(fmpq_poly_t poly, slong n) - void fmpq_poly_set_trunc(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void fmpq_poly_get_slice(fmpq_poly_t rop, const fmpq_poly_t op, slong i, slong j) - void fmpq_poly_reverse(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void fmpq_poly_get_coeff_fmpz(fmpz_t x, const fmpq_poly_t poly, slong n) - void fmpq_poly_get_coeff_fmpq(fmpq_t x, const fmpq_poly_t poly, slong n) - void fmpq_poly_set_coeff_si(fmpq_poly_t poly, slong n, slong x) - void fmpq_poly_set_coeff_ui(fmpq_poly_t poly, slong n, ulong x) - void fmpq_poly_set_coeff_fmpz(fmpq_poly_t poly, slong n, const fmpz_t x) - void fmpq_poly_set_coeff_fmpq(fmpq_poly_t poly, slong n, const fmpq_t x) - int fmpq_poly_equal(const fmpq_poly_t poly1, const fmpq_poly_t poly2) - int _fmpq_poly_equal_trunc(const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - int fmpq_poly_equal_trunc(const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - int _fmpq_poly_cmp(const fmpz_struct * lpoly, const fmpz_t lden, const fmpz_struct * rpoly, const fmpz_t rden, slong len) - int fmpq_poly_cmp(const fmpq_poly_t left, const fmpq_poly_t right) - int fmpq_poly_is_one(const fmpq_poly_t poly) - int fmpq_poly_is_zero(const fmpq_poly_t poly) - int fmpq_poly_is_gen(const fmpq_poly_t poly) - void _fmpq_poly_add(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2) - void _fmpq_poly_add_can(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, int can) - void fmpq_poly_add(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void fmpq_poly_add_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, int can) - void _fmpq_poly_add_series(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - void _fmpq_poly_add_series_can(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n, int can) - void fmpq_poly_add_series(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - void fmpq_poly_add_series_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n, int can) - void _fmpq_poly_sub(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2) - void _fmpq_poly_sub_can(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, int can) - void fmpq_poly_sub(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void fmpq_poly_sub_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, int can) - void _fmpq_poly_sub_series(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - void _fmpq_poly_sub_series_can(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n, int can) - void fmpq_poly_sub_series(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - void fmpq_poly_sub_series_can(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n, int can) - void _fmpq_poly_scalar_mul_si(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, slong c) - void _fmpq_poly_scalar_mul_ui(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, ulong c) - void _fmpq_poly_scalar_mul_fmpz(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t c) - void _fmpq_poly_scalar_mul_fmpq(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t r, const fmpz_t s) - void fmpq_poly_scalar_mul_fmpq(fmpq_poly_t rop, const fmpq_poly_t op, const fmpq_t c) - void fmpq_poly_scalar_mul_si(fmpq_poly_t rop, const fmpq_poly_t op, slong c) - void fmpq_poly_scalar_mul_ui(fmpq_poly_t rop, const fmpq_poly_t op, ulong c) - void fmpq_poly_scalar_mul_fmpz(fmpq_poly_t rop, const fmpq_poly_t op, const fmpz_t c) - void _fmpq_poly_scalar_div_fmpz(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t c) - void _fmpq_poly_scalar_div_si(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, slong c) - void _fmpq_poly_scalar_div_ui(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, ulong c) - void _fmpq_poly_scalar_div_fmpq(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t r, const fmpz_t s) - void fmpq_poly_scalar_div_si(fmpq_poly_t rop, const fmpq_poly_t op, slong c) - void fmpq_poly_scalar_div_ui(fmpq_poly_t rop, const fmpq_poly_t op, ulong c) - void fmpq_poly_scalar_div_fmpz(fmpq_poly_t rop, const fmpq_poly_t op, const fmpz_t c) - void fmpq_poly_scalar_div_fmpq(fmpq_poly_t rop, const fmpq_poly_t op, const fmpq_t c) - void _fmpq_poly_mul(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2) - void fmpq_poly_mul(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void _fmpq_poly_mullow(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - void fmpq_poly_mullow(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - void fmpq_poly_addmul(fmpq_poly_t rop, const fmpq_poly_t op1, const fmpq_poly_t op2) - void fmpq_poly_submul(fmpq_poly_t rop, const fmpq_poly_t op1, const fmpq_poly_t op2) - void _fmpq_poly_pow(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, ulong e) - void fmpq_poly_pow(fmpq_poly_t res, const fmpq_poly_t poly, ulong e) - void _fmpq_poly_pow_trunc(fmpz_struct * res, fmpz_t rden, const fmpz_struct * f, const fmpz_t fden, slong flen, ulong exp, slong len) - void fmpq_poly_pow_trunc(fmpq_poly_t res, const fmpq_poly_t poly, ulong e, slong n) - void fmpq_poly_shift_left(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void fmpq_poly_shift_right(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_divrem(fmpz_struct * Q, fmpz_t q, fmpz_struct * R, fmpz_t r, const fmpz_struct * A, const fmpz_t a, slong lenA, const fmpz_struct * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv) - void fmpq_poly_divrem(fmpq_poly_t Q, fmpq_poly_t R, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void _fmpq_poly_div(fmpz_struct * Q, fmpz_t q, const fmpz_struct * A, const fmpz_t a, slong lenA, const fmpz_struct * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv) - void fmpq_poly_div(fmpq_poly_t Q, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void _fmpq_poly_rem(fmpz_struct * R, fmpz_t r, const fmpz_struct * A, const fmpz_t a, slong lenA, const fmpz_struct * B, const fmpz_t b, slong lenB, const fmpz_preinvn_t inv) - void fmpq_poly_rem(fmpq_poly_t R, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - fmpq_poly_struct * _fmpq_poly_powers_precompute(const fmpz_struct * B, const fmpz_t denB, slong len) - # void fmpq_poly_powers_precompute(fmpq_poly_powers_precomp_t pinv, fmpq_poly_t poly) - void _fmpq_poly_powers_clear(fmpq_poly_struct * powers, slong len) - # void fmpq_poly_powers_clear(fmpq_poly_powers_precomp_t pinv) - void _fmpq_poly_rem_powers_precomp(fmpz_struct * A, fmpz_t denA, slong m, const fmpz_struct * B, const fmpz_t denB, slong n, fmpq_poly_struct * const powers) - # void fmpq_poly_rem_powers_precomp(fmpq_poly_t R, const fmpq_poly_t A, const fmpq_poly_t B, const fmpq_poly_powers_precomp_t B_inv) - int _fmpq_poly_divides(fmpz_struct * qpoly, fmpz_t qden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2) - int fmpq_poly_divides(fmpq_poly_t q, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - slong fmpq_poly_remove(fmpq_poly_t q, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void _fmpq_poly_inv_series_newton(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, slong n) - void fmpq_poly_inv_series_newton(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_inv_series(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong den_len, slong n) - void fmpq_poly_inv_series(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_div_series(fmpz_struct * Q, fmpz_t denQ, const fmpz_struct * A, const fmpz_t denA, slong lenA, const fmpz_struct * B, const fmpz_t denB, slong lenB, slong n) - void fmpq_poly_div_series(fmpq_poly_t Q, const fmpq_poly_t A, const fmpq_poly_t B, slong n) - void _fmpq_poly_gcd(fmpz_struct * G, fmpz_t denG, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpq_poly_gcd(fmpq_poly_t G, const fmpq_poly_t A, const fmpq_poly_t B) - void _fmpq_poly_xgcd(fmpz_struct * G, fmpz_t denG, fmpz_struct * S, fmpz_t denS, fmpz_struct * T, fmpz_t denT, const fmpz_struct * A, const fmpz_t denA, slong lenA, const fmpz_struct * B, const fmpz_t denB, slong lenB) - void fmpq_poly_xgcd(fmpq_poly_t G, fmpq_poly_t S, fmpq_poly_t T, const fmpq_poly_t A, const fmpq_poly_t B) - void _fmpq_poly_lcm(fmpz_struct * L, fmpz_t denL, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpq_poly_lcm(fmpq_poly_t L, const fmpq_poly_t A, const fmpq_poly_t B) - void _fmpq_poly_resultant(fmpz_t rnum, fmpz_t rden, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2) - void fmpq_poly_resultant(fmpq_t r, const fmpq_poly_t f, const fmpq_poly_t g) - void fmpq_poly_resultant_div(fmpq_t r, const fmpq_poly_t f, const fmpq_poly_t g, const fmpz_t div, slong nbits) - void _fmpq_poly_derivative(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len) - void fmpq_poly_derivative(fmpq_poly_t res, const fmpq_poly_t poly) - void _fmpq_poly_nth_derivative(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, ulong n, slong len) - void fmpq_poly_nth_derivative(fmpq_poly_t res, const fmpq_poly_t poly, ulong n) - void _fmpq_poly_integral(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len) - void fmpq_poly_integral(fmpq_poly_t res, const fmpq_poly_t poly) - void _fmpq_poly_sqrt_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_sqrt_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_invsqrt_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_invsqrt_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_power_sums(fmpz_struct * res, fmpz_t rden, const fmpz_struct * poly, slong len, slong n) - void fmpq_poly_power_sums(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_power_sums_to_poly(fmpz_struct * res, const fmpz_struct * poly, const fmpz_t den, slong len) - void fmpq_poly_power_sums_to_fmpz_poly(fmpz_poly_t res, const fmpq_poly_t Q) - void fmpq_poly_power_sums_to_poly(fmpq_poly_t res, const fmpq_poly_t Q) - void _fmpq_poly_log_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_log_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_exp_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * h, const fmpz_t hden, slong hlen, slong n) - void fmpq_poly_exp_series(fmpq_poly_t res, const fmpq_poly_t h, slong n) - void _fmpq_poly_exp_expinv_series(fmpz_struct * res1, fmpz_t res1den, fmpz_struct * res2, fmpz_t res2den, const fmpz_struct * h, const fmpz_t hden, slong hlen, slong n) - void fmpq_poly_exp_expinv_series(fmpq_poly_t res1, fmpq_poly_t res2, const fmpq_poly_t h, slong n) - void _fmpq_poly_atan_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_atan_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_atanh_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_atanh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_asin_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_asin_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_asinh_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_asinh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_tan_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_tan_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_sin_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_sin_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_cos_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_cos_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_sin_cos_series(fmpz_struct * s, fmpz_t sden, fmpz_struct * c, fmpz_t cden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_sin_cos_series(fmpq_poly_t res1, fmpq_poly_t res2, const fmpq_poly_t f, slong n) - void _fmpq_poly_sinh_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_sinh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_cosh_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_cosh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_sinh_cosh_series(fmpz_struct * s, fmpz_t sden, fmpz_struct * c, fmpz_t cden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_sinh_cosh_series(fmpq_poly_t res1, fmpq_poly_t res2, const fmpq_poly_t f, slong n) - void _fmpq_poly_tanh_series(fmpz_struct * g, fmpz_t gden, const fmpz_struct * f, const fmpz_t fden, slong flen, slong n) - void fmpq_poly_tanh_series(fmpq_poly_t res, const fmpq_poly_t f, slong n) - void _fmpq_poly_legendre_p(fmpz_struct * coeffs, fmpz_t den, ulong n) - void fmpq_poly_legendre_p(fmpq_poly_t poly, ulong n) - void _fmpq_poly_laguerre_l(fmpz_struct * coeffs, fmpz_t den, ulong n) - void fmpq_poly_laguerre_l(fmpq_poly_t poly, ulong n) - void _fmpq_poly_gegenbauer_c(fmpz_struct * coeffs, fmpz_t den, ulong n, const fmpq_t a) - void fmpq_poly_gegenbauer_c(fmpq_poly_t poly, ulong n, const fmpq_t a) - void _fmpq_poly_evaluate_fmpz(fmpz_t rnum, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t a) - void fmpq_poly_evaluate_fmpz(fmpq_t res, const fmpq_poly_t poly, const fmpz_t a) - void _fmpq_poly_evaluate_fmpq(fmpz_t rnum, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t anum, const fmpz_t aden) - void fmpq_poly_evaluate_fmpq(fmpq_t res, const fmpq_poly_t poly, const fmpq_t a) - void _fmpq_poly_interpolate_fmpz_vec(fmpz_struct * poly, fmpz_t den, const fmpz_struct * xs, const fmpz_struct * ys, slong n) - void fmpq_poly_interpolate_fmpz_vec(fmpq_poly_t poly, const fmpz_struct * xs, const fmpz_struct * ys, slong n) - void _fmpq_poly_compose(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2) - void fmpq_poly_compose(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2) - void _fmpq_poly_rescale(fmpz_struct * res, fmpz_t denr, const fmpz_struct * poly, const fmpz_t den, slong len, const fmpz_t anum, const fmpz_t aden) - void fmpq_poly_rescale(fmpq_poly_t res, const fmpq_poly_t poly, const fmpq_t a) - void _fmpq_poly_compose_series_horner(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - void fmpq_poly_compose_series_horner(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - void _fmpq_poly_compose_series_brent_kung(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - void fmpq_poly_compose_series_brent_kung(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - void _fmpq_poly_compose_series(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, const fmpz_struct * poly2, const fmpz_t den2, slong len2, slong n) - void fmpq_poly_compose_series(fmpq_poly_t res, const fmpq_poly_t poly1, const fmpq_poly_t poly2, slong n) - void _fmpq_poly_revert_series_lagrange(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, slong n) - void fmpq_poly_revert_series_lagrange(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_revert_series_lagrange_fast(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, slong n) - void fmpq_poly_revert_series_lagrange_fast(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_revert_series_newton(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, slong n) - void fmpq_poly_revert_series_newton(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_revert_series(fmpz_struct * res, fmpz_t den, const fmpz_struct * poly1, const fmpz_t den1, slong len1, slong n) - void fmpq_poly_revert_series(fmpq_poly_t res, const fmpq_poly_t poly, slong n) - void _fmpq_poly_content(fmpq_t res, const fmpz_struct * poly, const fmpz_t den, slong len) - void fmpq_poly_content(fmpq_t res, const fmpq_poly_t poly) - void _fmpq_poly_primitive_part(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len) - void fmpq_poly_primitive_part(fmpq_poly_t res, const fmpq_poly_t poly) - int _fmpq_poly_is_monic(const fmpz_struct * poly, const fmpz_t den, slong len) - int fmpq_poly_is_monic(const fmpq_poly_t poly) - void _fmpq_poly_make_monic(fmpz_struct * rpoly, fmpz_t rden, const fmpz_struct * poly, const fmpz_t den, slong len) - void fmpq_poly_make_monic(fmpq_poly_t res, const fmpq_poly_t poly) - int fmpq_poly_is_squarefree(const fmpq_poly_t poly) - int _fmpq_poly_print(const fmpz_struct * poly, const fmpz_t den, slong len) - int fmpq_poly_print(const fmpq_poly_t poly) - int _fmpq_poly_print_pretty(const fmpz_struct * poly, const fmpz_t den, slong len, const char * x) - int fmpq_poly_print_pretty(const fmpq_poly_t poly, const char * var) - # int _fmpq_poly_fprint(FILE * file, const fmpz_struct * poly, const fmpz_t den, slong len) - # int fmpq_poly_fprint(FILE * file, const fmpq_poly_t poly) - # int _fmpq_poly_fprint_pretty(FILE * file, const fmpz_struct * poly, const fmpz_t den, slong len, const char * x) - # int fmpq_poly_fprint_pretty(FILE * file, const fmpq_poly_t poly, const char * var) - int fmpq_poly_read(fmpq_poly_t poly) - # int fmpq_poly_fread(FILE * file, fmpq_poly_t poly) diff --git a/src/flint/flintlib/functions/fmpq_vec.pxd b/src/flint/flintlib/functions/fmpq_vec.pxd deleted file mode 100644 index 8d0abb85..00000000 --- a/src/flint/flintlib/functions/fmpq_vec.pxd +++ /dev/null @@ -1,17 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong -from flint.flintlib.types.fmpq cimport fmpq_struct, fmpq_t - -# unknown type FILE - - -cdef extern from "flint/fmpq_vec.h": - fmpq_struct * _fmpq_vec_init(slong n) - void _fmpq_vec_clear(fmpq_struct * vec, slong n) - void _fmpq_vec_randtest(fmpq_struct * f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void _fmpq_vec_randtest_uniq_sorted(fmpq_struct * vec, flint_rand_t state, slong len, flint_bitcnt_t bits) - void _fmpq_vec_sort(fmpq_struct * vec, slong len) - void _fmpq_vec_set_fmpz_vec(fmpq_struct * res, const fmpz_struct * vec, slong len) - void _fmpq_vec_get_fmpz_vec_fmpz(fmpz_struct * num, fmpz_t den, const fmpq_struct * a, slong len) - void _fmpq_vec_dot(fmpq_t res, const fmpq_struct * vec1, const fmpq_struct * vec2, slong len) - # int _fmpq_vec_fprint(FILE * file, const fmpq_struct * vec, slong len) - int _fmpq_vec_print(const fmpq_struct * vec, slong len) diff --git a/src/flint/flintlib/functions/fmpz.pxd b/src/flint/flintlib/functions/fmpz.pxd deleted file mode 100644 index 07cede32..00000000 --- a/src/flint/flintlib/functions/fmpz.pxd +++ /dev/null @@ -1,259 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, nmod_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_factor_t, fmpz_preinvn_t - -# unknown type FILE -# unknown type fmpz_comb_t -# unknown type fmpz_comb_temp_t -# unknown type fmpz_multi_CRT_t -# unknown type mpf_t -# unknown type mpfr_rnd_t -# unknown type mpfr_t -# unknown type mpz_ptr -# unknown type mpz_t -# unknown type size_t - -# .. macro:: COEFF_MAX -# .. macro:: COEFF_MIN -# .. macro:: COEFF_IS_MPZ(f) -# .. macro:: MPZ_MIN_ALLOC - -cdef extern from "flint/fmpz.h": - # fmpz_struct PTR_TO_COEFF(mpz_ptr ptr) - # mpz_ptr COEFF_TO_PTR(fmpz_struct f) - # mpz_ptr _fmpz_new_mpz(void) - void _fmpz_clear_mpz(fmpz_struct f) - void _fmpz_cleanup_mpz_content() - void _fmpz_cleanup() - # mpz_ptr _fmpz_promote(fmpz_t f) - # mpz_ptr _fmpz_promote_val(fmpz_t f) - void _fmpz_demote(fmpz_t f) - void _fmpz_demote_val(fmpz_t f) - int _fmpz_is_canonical(const fmpz_t f) - void fmpz_init(fmpz_t f) - void fmpz_init2(fmpz_t f, ulong limbs) - void fmpz_clear(fmpz_t f) - void fmpz_init_set(fmpz_t f, const fmpz_t g) - void fmpz_init_set_ui(fmpz_t f, ulong g) - void fmpz_init_set_si(fmpz_t f, slong g) - void fmpz_randbits_unsigned(fmpz_t f, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_randbits(fmpz_t f, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_randtest_unsigned(fmpz_t f, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_randtest(fmpz_t f, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_randtest_not_zero(fmpz_t f, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_randm(fmpz_t f, flint_rand_t state, const fmpz_t m) - void fmpz_randtest_mod(fmpz_t f, flint_rand_t state, const fmpz_t m) - void fmpz_randtest_mod_signed(fmpz_t f, flint_rand_t state, const fmpz_t m) - void fmpz_randprime(fmpz_t f, flint_rand_t state, flint_bitcnt_t bits, int proved) - slong fmpz_get_si(const fmpz_t f) - ulong fmpz_get_ui(const fmpz_t f) - void fmpz_get_uiui(ulong * hi, ulong * low, const fmpz_t f) - ulong fmpz_get_nmod(const fmpz_t f, nmod_t mod) - double fmpz_get_d(const fmpz_t f) - # void fmpz_set_mpf(fmpz_t f, const mpf_t x) - # void fmpz_get_mpf(mpf_t x, const fmpz_t f) - # void fmpz_get_mpfr(mpfr_t x, const fmpz_t f, mpfr_rnd_t rnd) - double fmpz_get_d_2exp(slong * exp, const fmpz_t f) - # void fmpz_get_mpz(mpz_t x, const fmpz_t f) - int fmpz_get_mpn(nn_ptr * n, fmpz_t n_in) - char * fmpz_get_str(char * str, int b, const fmpz_t f) - void fmpz_set_si(fmpz_t f, slong val) - void fmpz_set_ui(fmpz_t f, ulong val) - void fmpz_set_d(fmpz_t f, double c) - void fmpz_set_d_2exp(fmpz_t f, double d, slong exp) - void fmpz_neg_ui(fmpz_t f, ulong val) - void fmpz_set_uiui(fmpz_t f, ulong hi, ulong lo) - void fmpz_neg_uiui(fmpz_t f, ulong hi, ulong lo) - void fmpz_set_signed_uiui(fmpz_t f, ulong hi, ulong lo) - void fmpz_set_signed_uiuiui(fmpz_t f, ulong hi, ulong mid, ulong lo) - void fmpz_set_ui_array(fmpz_t out, const ulong * in_, slong n) - void fmpz_set_signed_ui_array(fmpz_t out, const ulong * in_, slong n) - void fmpz_get_ui_array(ulong * out, slong n, const fmpz_t in_) - void fmpz_get_signed_ui_array(ulong * out, slong n, const fmpz_t in_) - void fmpz_set_mpn_large(fmpz_t z, nn_srcptr src, slong n, int negative) - void fmpz_get_signed_uiui(ulong * hi, ulong * lo, const fmpz_t in_) - # void fmpz_set_mpz(fmpz_t f, const mpz_t x) - int fmpz_set_str(fmpz_t f, const char * str, int b) - void fmpz_set_ui_smod(fmpz_t f, ulong x, ulong m) - # void flint_mpz_init_set_readonly(mpz_t z, const fmpz_t f) - # void flint_mpz_clear_readonly(mpz_t z) - # void fmpz_init_set_readonly(fmpz_t f, const mpz_t z) - void fmpz_clear_readonly(fmpz_t f) - int fmpz_read(fmpz_t f) - # int fmpz_fread(FILE * file, fmpz_t f) - # size_t fmpz_inp_raw(fmpz_t x, FILE * fin) - # int fmpz_fprint(FILE * fs, const fmpz_t x) - int fmpz_print(const fmpz_t x) - # size_t fmpz_out_raw(FILE * fout, const fmpz_t x ) - # size_t fmpz_sizeinbase(const fmpz_t f, int b) - flint_bitcnt_t fmpz_bits(const fmpz_t f) - slong fmpz_size(const fmpz_t f) - int fmpz_sgn(const fmpz_t f) - flint_bitcnt_t fmpz_val2(const fmpz_t f) - void fmpz_swap(fmpz_t f, fmpz_t g) - void fmpz_set(fmpz_t f, const fmpz_t g) - void fmpz_zero(fmpz_t f) - void fmpz_one(fmpz_t f) - int fmpz_abs_fits_ui(const fmpz_t f) - int fmpz_fits_si(const fmpz_t f) - void fmpz_setbit(fmpz_t f, ulong i) - int fmpz_tstbit(const fmpz_t f, ulong i) - ulong fmpz_abs_lbound_ui_2exp(slong * exp, const fmpz_t x, int bits) - ulong fmpz_abs_ubound_ui_2exp(slong * exp, const fmpz_t x, int bits) - int fmpz_cmp(const fmpz_t f, const fmpz_t g) - int fmpz_cmp_ui(const fmpz_t f, ulong g) - int fmpz_cmp_si(const fmpz_t f, slong g) - int fmpz_cmpabs(const fmpz_t f, const fmpz_t g) - int fmpz_cmp2abs(const fmpz_t f, const fmpz_t g) - int fmpz_equal(const fmpz_t f, const fmpz_t g) - int fmpz_equal_ui(const fmpz_t f, ulong g) - int fmpz_equal_si(const fmpz_t f, slong g) - int fmpz_is_zero(const fmpz_t f) - int fmpz_is_one(const fmpz_t f) - int fmpz_is_pm1(const fmpz_t f) - int fmpz_is_even(const fmpz_t f) - int fmpz_is_odd(const fmpz_t f) - void fmpz_neg(fmpz_t f1, const fmpz_t f2) - void fmpz_abs(fmpz_t f1, const fmpz_t f2) - void fmpz_add(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_add_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_add_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_sub(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_sub_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_sub_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_mul(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_mul_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_mul_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_mul2_uiui(fmpz_t f, const fmpz_t g, ulong x, ulong y) - void fmpz_mul_2exp(fmpz_t f, const fmpz_t g, ulong e) - void fmpz_one_2exp(fmpz_t f, ulong e) - void fmpz_addmul(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_addmul_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_addmul_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_submul(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_submul_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_submul_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_fmma(fmpz_t f, const fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_t d) - void fmpz_fmms(fmpz_t f, const fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_t d) - void fmpz_cdiv_qr(fmpz_t f, fmpz_t s, const fmpz_t g, const fmpz_t h) - void fmpz_fdiv_qr(fmpz_t f, fmpz_t s, const fmpz_t g, const fmpz_t h) - void fmpz_tdiv_qr(fmpz_t f, fmpz_t s, const fmpz_t g, const fmpz_t h) - void fmpz_ndiv_qr(fmpz_t f, fmpz_t s, const fmpz_t g, const fmpz_t h) - void fmpz_cdiv_q(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_fdiv_q(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_tdiv_q(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_cdiv_q_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_fdiv_q_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_tdiv_q_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_cdiv_q_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_fdiv_q_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_tdiv_q_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_cdiv_q_2exp(fmpz_t f, const fmpz_t g, ulong exp) - void fmpz_fdiv_q_2exp(fmpz_t f, const fmpz_t g, ulong exp) - void fmpz_tdiv_q_2exp(fmpz_t f, const fmpz_t g, ulong exp) - void fmpz_fdiv_r(fmpz_t s, const fmpz_t g, const fmpz_t h) - void fmpz_cdiv_r_2exp(fmpz_t s, const fmpz_t g, ulong exp) - void fmpz_fdiv_r_2exp(fmpz_t s, const fmpz_t g, ulong exp) - void fmpz_tdiv_r_2exp(fmpz_t s, const fmpz_t g, ulong exp) - ulong fmpz_cdiv_ui(const fmpz_t g, ulong h) - ulong fmpz_fdiv_ui(const fmpz_t g, ulong h) - ulong fmpz_tdiv_ui(const fmpz_t g, ulong h) - void fmpz_divexact(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_divexact_si(fmpz_t f, const fmpz_t g, slong h) - void fmpz_divexact_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_divexact2_uiui(fmpz_t f, const fmpz_t g, ulong x, ulong y) - int fmpz_divisible(const fmpz_t f, const fmpz_t g) - int fmpz_divisible_si(const fmpz_t f, slong g) - int fmpz_divides(fmpz_t q, const fmpz_t f, const fmpz_t g) - void fmpz_mod(fmpz_t f, const fmpz_t g, const fmpz_t h) - ulong fmpz_mod_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_smod(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_preinvn_init(fmpz_preinvn_t inv, const fmpz_t f) - void fmpz_preinvn_clear(fmpz_preinvn_t inv) - void fmpz_fdiv_qr_preinvn(fmpz_t f, fmpz_t s, const fmpz_t g, const fmpz_t h, const fmpz_preinvn_t hinv) - void fmpz_pow_ui(fmpz_t f, const fmpz_t g, ulong x) - void fmpz_ui_pow_ui(fmpz_t f, ulong g, ulong x) - int fmpz_pow_fmpz(fmpz_t f, const fmpz_t g, const fmpz_t x) - void fmpz_powm_ui(fmpz_t f, const fmpz_t g, ulong e, const fmpz_t m) - void fmpz_powm(fmpz_t f, const fmpz_t g, const fmpz_t e, const fmpz_t m) - slong fmpz_clog(const fmpz_t x, const fmpz_t b) - slong fmpz_clog_ui(const fmpz_t x, ulong b) - slong fmpz_flog(const fmpz_t x, const fmpz_t b) - slong fmpz_flog_ui(const fmpz_t x, ulong b) - double fmpz_dlog(const fmpz_t x) - int fmpz_sqrtmod(fmpz_t b, const fmpz_t a, const fmpz_t p) - void fmpz_sqrt(fmpz_t f, const fmpz_t g) - void fmpz_sqrtrem(fmpz_t f, fmpz_t r, const fmpz_t g) - int fmpz_is_square(const fmpz_t f) - int fmpz_root(fmpz_t r, const fmpz_t f, slong n) - int fmpz_is_perfect_power(fmpz_t root, const fmpz_t f) - void fmpz_fac_ui(fmpz_t f, ulong n) - void fmpz_fib_ui(fmpz_t f, ulong n) - void fmpz_bin_uiui(fmpz_t f, ulong n, ulong k) - void _fmpz_rfac_ui(fmpz_t r, const fmpz_t x, ulong a, ulong b) - void fmpz_rfac_ui(fmpz_t r, const fmpz_t x, ulong k) - void fmpz_rfac_uiui(fmpz_t r, ulong x, ulong k) - void fmpz_mul_tdiv_q_2exp(fmpz_t f, const fmpz_t g, const fmpz_t h, ulong exp) - void fmpz_mul_si_tdiv_q_2exp(fmpz_t f, const fmpz_t g, slong x, ulong exp) - void fmpz_gcd_ui(fmpz_t f, const fmpz_t g, ulong h) - void fmpz_gcd(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_gcd3(fmpz_t f, const fmpz_t a, const fmpz_t b, const fmpz_t c) - void fmpz_lcm(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_gcdinv(fmpz_t d, fmpz_t a, const fmpz_t f, const fmpz_t g) - void fmpz_xgcd(fmpz_t d, fmpz_t a, fmpz_t b, const fmpz_t f, const fmpz_t g) - void fmpz_xgcd_canonical_bezout(fmpz_t d, fmpz_t a, fmpz_t b, const fmpz_t f, const fmpz_t g) - void fmpz_xgcd_partial(fmpz_t co2, fmpz_t co1, fmpz_t r2, fmpz_t r1, const fmpz_t L) - slong _fmpz_remove(fmpz_t x, const fmpz_t f, double finv) - slong fmpz_remove(fmpz_t rop, const fmpz_t op, const fmpz_t f) - int fmpz_invmod(fmpz_t f, const fmpz_t g, const fmpz_t h) - void fmpz_negmod(fmpz_t f, const fmpz_t g, const fmpz_t h) - int fmpz_jacobi(const fmpz_t a, const fmpz_t n) - int fmpz_kronecker(const fmpz_t a, const fmpz_t n) - void fmpz_divides_mod_list(fmpz_t xstart, fmpz_t xstride, fmpz_t xlength, const fmpz_t a, const fmpz_t b, const fmpz_t n) - int fmpz_bit_pack(ulong * arr, flint_bitcnt_t shift, flint_bitcnt_t bits, const fmpz_t coeff, int negate, int borrow) - int fmpz_bit_unpack(fmpz_t coeff, ulong * arr, flint_bitcnt_t shift, flint_bitcnt_t bits, int negate, int borrow) - void fmpz_bit_unpack_unsigned(fmpz_t coeff, const ulong * arr, flint_bitcnt_t shift, flint_bitcnt_t bits) - void fmpz_complement(fmpz_t r, const fmpz_t f) - void fmpz_clrbit(fmpz_t f, ulong i) - void fmpz_combit(fmpz_t f, ulong i) - void fmpz_and(fmpz_t r, const fmpz_t a, const fmpz_t b) - void fmpz_or(fmpz_t r, const fmpz_t a, const fmpz_t b) - void fmpz_xor(fmpz_t r, const fmpz_t a, const fmpz_t b) - ulong fmpz_popcnt(const fmpz_t a) - void fmpz_CRT_ui(fmpz_t out, const fmpz_t r1, const fmpz_t m1, ulong r2, ulong m2, int sign) - void fmpz_CRT(fmpz_t out, const fmpz_t r1, const fmpz_t m1, const fmpz_t r2, const fmpz_t m2, int sign) - # void fmpz_multi_mod_ui(ulong * out, const fmpz_t in_, const fmpz_comb_t comb, fmpz_comb_temp_t temp) - # void fmpz_multi_CRT_ui(fmpz_t output, nn_srcptr residues, const fmpz_comb_t comb, fmpz_comb_temp_t ctemp, int sign) - # void fmpz_comb_init(fmpz_comb_t comb, nn_srcptr primes, slong num_primes) - # void fmpz_comb_temp_init(fmpz_comb_temp_t temp, const fmpz_comb_t comb) - # void fmpz_comb_clear(fmpz_comb_t comb) - # void fmpz_comb_temp_clear(fmpz_comb_temp_t temp) - # void fmpz_multi_CRT_init(fmpz_multi_CRT_t CRT) - # int fmpz_multi_CRT_precompute(fmpz_multi_CRT_t CRT, const fmpz_struct * moduli, slong len) - # void fmpz_multi_CRT_precomp(fmpz_t output, const fmpz_multi_CRT_t P, const fmpz_struct * inputs, int sign) - int fmpz_multi_CRT(fmpz_t output, const fmpz_struct * moduli, const fmpz_struct * values, slong len, int sign) - # void fmpz_multi_CRT_clear(fmpz_multi_CRT_t P) - int fmpz_is_strong_probabprime(const fmpz_t n, const fmpz_t a) - int fmpz_is_probabprime_lucas(const fmpz_t n) - int fmpz_is_probabprime_BPSW(const fmpz_t n) - int fmpz_is_probabprime(const fmpz_t p) - int fmpz_is_prime_pseudosquare(const fmpz_t n) - int fmpz_is_prime_pocklington(fmpz_t F, fmpz_t R, const fmpz_t n, nn_ptr pm1, slong num_pm1) - void _fmpz_nm1_trial_factors(const fmpz_t n, nn_ptr pm1, slong * num_pm1, ulong limit) - int fmpz_is_prime_morrison(fmpz_t F, fmpz_t R, const fmpz_t n, nn_ptr pp1, slong num_pp1) - void _fmpz_np1_trial_factors(const fmpz_t n, nn_ptr pp1, slong * num_pp1, ulong limit) - int fmpz_is_prime(const fmpz_t n) - void fmpz_lucas_chain(fmpz_t Vm, fmpz_t Vm1, const fmpz_t A, const fmpz_t m, const fmpz_t n) - void fmpz_lucas_chain_full(fmpz_t Vm, fmpz_t Vm1, const fmpz_t A, const fmpz_t B, const fmpz_t m, const fmpz_t n) - void fmpz_lucas_chain_double(fmpz_t U2m, fmpz_t U2m1, const fmpz_t Um, const fmpz_t Um1, const fmpz_t A, const fmpz_t B, const fmpz_t n) - void fmpz_lucas_chain_add(fmpz_t Umn, fmpz_t Umn1, const fmpz_t Um, const fmpz_t Um1, const fmpz_t Un, const fmpz_t Un1, const fmpz_t A, const fmpz_t B, const fmpz_t n) - void fmpz_lucas_chain_mul(fmpz_t Ukm, fmpz_t Ukm1, const fmpz_t Um, const fmpz_t Um1, const fmpz_t A, const fmpz_t B, const fmpz_t k, const fmpz_t n) - void fmpz_lucas_chain_VtoU(fmpz_t Um, fmpz_t Um1, const fmpz_t Vm, const fmpz_t Vm1, const fmpz_t A, const fmpz_t B, const fmpz_t Dinv, const fmpz_t n) - int fmpz_divisor_in_residue_class_lenstra(fmpz_t fac, const fmpz_t n, const fmpz_t r, const fmpz_t s) - void fmpz_nextprime(fmpz_t res, const fmpz_t n, int proved) - void fmpz_primorial(fmpz_t res, ulong n) - void fmpz_factor_euler_phi(fmpz_t res, const fmpz_factor_t fac) - void fmpz_euler_phi(fmpz_t res, const fmpz_t n) - int fmpz_factor_moebius_mu(const fmpz_factor_t fac) - int fmpz_moebius_mu(const fmpz_t n) - void fmpz_factor_divisor_sigma(fmpz_t res, ulong k, const fmpz_factor_t fac) - void fmpz_divisor_sigma(fmpz_t res, ulong k, const fmpz_t n) diff --git a/src/flint/flintlib/functions/fmpz_factor.pxd b/src/flint/flintlib/functions/fmpz_factor.pxd deleted file mode 100644 index 3afe2e54..00000000 --- a/src/flint/flintlib/functions/fmpz_factor.pxd +++ /dev/null @@ -1,33 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, nn_ptr, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_factor_t - -# unknown type FILE -# unknown type ecm_t - - -cdef extern from "flint/fmpz_factor.h": - void fmpz_factor_init(fmpz_factor_t factor) - void fmpz_factor_clear(fmpz_factor_t factor) - void _fmpz_factor_append_ui(fmpz_factor_t factor, ulong p, ulong exp) - void _fmpz_factor_append(fmpz_factor_t factor, const fmpz_t p, ulong exp) - void fmpz_factor(fmpz_factor_t factor, const fmpz_t n) - int fmpz_factor_smooth(fmpz_factor_t factor, const fmpz_t n, slong bits, int proved) - void fmpz_factor_si(fmpz_factor_t factor, slong n) - int fmpz_factor_trial_range(fmpz_factor_t factor, const fmpz_t n, ulong start, ulong num_primes) - int fmpz_factor_trial(fmpz_factor_t factor, const fmpz_t n, slong num_primes) - void fmpz_factor_refine(fmpz_factor_t res, const fmpz_factor_t f) - void fmpz_factor_expand_iterative(fmpz_t n, const fmpz_factor_t factor) - int fmpz_factor_pp1(fmpz_t factor, const fmpz_t n, ulong B1, ulong B2_sqrt, ulong c) - int fmpz_factor_pollard_brent_single(fmpz_t p_factor, fmpz_t n_in, fmpz_t yi, fmpz_t ai, ulong max_iters) - int fmpz_factor_pollard_brent(fmpz_t factor, flint_rand_t state, fmpz_t n, ulong max_tries, ulong max_iters) - # int fmpz_factor_fprint(FILE * fs, const fmpz_factor_t factor) - int fmpz_factor_print(const fmpz_factor_t factor) - # void fmpz_factor_ecm_init(ecm_t ecm_inf, ulong sz) - # void fmpz_factor_ecm_clear(ecm_t ecm_inf) - # void fmpz_factor_ecm_double(nn_ptr x, nn_ptr z, nn_ptr x0, nn_ptr z0, nn_ptr n, ecm_t ecm_inf) - # void fmpz_factor_ecm_add(nn_ptr x, nn_ptr z, nn_ptr x1, nn_ptr z1, nn_ptr x2, nn_ptr z2, nn_ptr x0, nn_ptr z0, nn_ptr n, ecm_t ecm_inf) - # void fmpz_factor_ecm_mul_montgomery_ladder(nn_ptr x, nn_ptr z, nn_ptr x0, nn_ptr z0, ulong k, nn_ptr n, ecm_t ecm_inf) - # int fmpz_factor_ecm_select_curve(nn_ptr f, nn_ptr sigma, nn_ptr n, ecm_t ecm_inf) - # int fmpz_factor_ecm_stage_I(nn_ptr f, const ulong * prime_array, ulong num, ulong B1, nn_ptr n, ecm_t ecm_inf) - # int fmpz_factor_ecm_stage_II(nn_ptr f, ulong B1, ulong B2, ulong P, nn_ptr n, ecm_t ecm_inf) - int fmpz_factor_ecm(fmpz_t f, ulong curves, ulong B1, ulong B2, flint_rand_t state, const fmpz_t n_in) diff --git a/src/flint/flintlib/functions/fmpz_lll.pxd b/src/flint/flintlib/functions/fmpz_lll.pxd deleted file mode 100644 index 1edaff7f..00000000 --- a/src/flint/flintlib/functions/fmpz_lll.pxd +++ /dev/null @@ -1,43 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_t, slong -from flint.flintlib.types.fmpz cimport fmpz_lll_t, fmpz_mat_t, gram_type, rep_type - -# unknown type d_mat_t -# unknown type fmpz_gram_t -# unknown type mpf -# unknown type mpf_mat_t -# unknown type mpf_t - - -cdef extern from "flint/fmpz_lll.h": - void fmpz_lll_context_init_default(fmpz_lll_t fl) - void fmpz_lll_context_init(fmpz_lll_t fl, double delta, double eta, rep_type rt, gram_type gt) - void fmpz_lll_randtest(fmpz_lll_t fl, flint_rand_t state) - double fmpz_lll_heuristic_dot(const double * vec1, const double * vec2, slong len2, const fmpz_mat_t B, slong k, slong j, slong exp_adj) - # int fmpz_lll_check_babai(int kappa, fmpz_mat_t B, fmpz_mat_t U, d_mat_t mu, d_mat_t r, double * s, d_mat_t appB, int * expo, fmpz_gram_t A, int a, int zeros, int kappamax, int n, const fmpz_lll_t fl) - # int fmpz_lll_check_babai_heuristic_d(int kappa, fmpz_mat_t B, fmpz_mat_t U, d_mat_t mu, d_mat_t r, double * s, d_mat_t appB, int * expo, fmpz_gram_t A, int a, int zeros, int kappamax, int n, const fmpz_lll_t fl) - # int fmpz_lll_check_babai_heuristic(int kappa, fmpz_mat_t B, fmpz_mat_t U, mpf_mat_t mu, mpf_mat_t r, mpf * s, mpf_mat_t appB, fmpz_gram_t A, int a, int zeros, int kappamax, int n, mpf_t tmp, mpf_t rtmp, flint_bitcnt_t prec, const fmpz_lll_t fl) - # int fmpz_lll_advance_check_babai(int cur_kappa, int kappa, fmpz_mat_t B, fmpz_mat_t U, d_mat_t mu, d_mat_t r, double * s, d_mat_t appB, int * expo, fmpz_gram_t A, int a, int zeros, int kappamax, int n, const fmpz_lll_t fl) - # int fmpz_lll_advance_check_babai_heuristic_d(int cur_kappa, int kappa, fmpz_mat_t B, fmpz_mat_t U, d_mat_t mu, d_mat_t r, double * s, d_mat_t appB, int * expo, fmpz_gram_t A, int a, int zeros, int kappamax, int n, const fmpz_lll_t fl) - int fmpz_lll_shift(const fmpz_mat_t B) - int fmpz_lll_d(fmpz_mat_t B, fmpz_mat_t U, const fmpz_lll_t fl) - int fmpz_lll_d_heuristic(fmpz_mat_t B, fmpz_mat_t U, const fmpz_lll_t fl) - int fmpz_lll_mpf2(fmpz_mat_t B, fmpz_mat_t U, flint_bitcnt_t prec, const fmpz_lll_t fl) - int fmpz_lll_mpf(fmpz_mat_t B, fmpz_mat_t U, const fmpz_lll_t fl) - int fmpz_lll_wrapper(fmpz_mat_t B, fmpz_mat_t U, const fmpz_lll_t fl) - int fmpz_lll_d_with_removal(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_d_heuristic_with_removal(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_mpf2_with_removal(fmpz_mat_t B, fmpz_mat_t U, flint_bitcnt_t prec, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_mpf_with_removal(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_wrapper_with_removal(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_d_with_removal_knapsack(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_wrapper_with_removal_knapsack(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_with_removal_ulll(fmpz_mat_t FM, fmpz_mat_t UM, slong new_size, const fmpz_t gs_B, const fmpz_lll_t fl) - int fmpz_lll_is_reduced_d(const fmpz_mat_t B, const fmpz_lll_t fl) - int fmpz_lll_is_reduced_mpfr(const fmpz_mat_t B, const fmpz_lll_t fl, flint_bitcnt_t prec) - int fmpz_lll_is_reduced_d_with_removal(const fmpz_mat_t B, const fmpz_lll_t fl, const fmpz_t gs_B, int newd) - int fmpz_lll_is_reduced_mpfr_with_removal(const fmpz_mat_t B, const fmpz_lll_t fl, const fmpz_t gs_B, int newd, flint_bitcnt_t prec) - int fmpz_lll_is_reduced(const fmpz_mat_t B, const fmpz_lll_t fl, flint_bitcnt_t prec) - int fmpz_lll_is_reduced_with_removal(const fmpz_mat_t B, const fmpz_lll_t fl, const fmpz_t gs_B, int newd, flint_bitcnt_t prec) - void fmpz_lll_storjohann_ulll(fmpz_mat_t FM, slong new_size, const fmpz_lll_t fl) - void fmpz_lll(fmpz_mat_t B, fmpz_mat_t U, const fmpz_lll_t fl) - int fmpz_lll_with_removal(fmpz_mat_t B, fmpz_mat_t U, const fmpz_t gs_B, const fmpz_lll_t fl) diff --git a/src/flint/flintlib/functions/fmpz_mat.pxd b/src/flint/flintlib/functions/fmpz_mat.pxd deleted file mode 100644 index 48718a0c..00000000 --- a/src/flint/flintlib/functions/fmpz_mat.pxd +++ /dev/null @@ -1,177 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mat_t, fmpz_poly_t -from flint.flintlib.types.nmod cimport nmod_mat_t - -# unknown type FILE -# unknown type d_mat_t -# unknown type fmpz_comb_t -# unknown type fmpz_comb_temp_t - - -cdef extern from "flint/fmpz_mat.h": - void fmpz_mat_init(fmpz_mat_t mat, slong rows, slong cols) - void fmpz_mat_clear(fmpz_mat_t mat) - void fmpz_mat_set(fmpz_mat_t mat1, const fmpz_mat_t mat2) - void fmpz_mat_init_set(fmpz_mat_t mat, const fmpz_mat_t src) - slong fmpz_mat_nrows(const fmpz_mat_t mat) - slong fmpz_mat_ncols(const fmpz_mat_t mat) - void fmpz_mat_swap(fmpz_mat_t mat1, fmpz_mat_t mat2) - void fmpz_mat_swap_entrywise(fmpz_mat_t mat1, fmpz_mat_t mat2) - fmpz_struct * fmpz_mat_entry(const fmpz_mat_t mat, slong i, slong j) - void fmpz_mat_zero(fmpz_mat_t mat) - void fmpz_mat_one(fmpz_mat_t mat) - void fmpz_mat_swap_rows(fmpz_mat_t mat, slong * perm, slong r, slong s) - void fmpz_mat_swap_cols(fmpz_mat_t mat, slong * perm, slong r, slong s) - void fmpz_mat_invert_rows(fmpz_mat_t mat, slong * perm) - void fmpz_mat_invert_cols(fmpz_mat_t mat, slong * perm) - void fmpz_mat_window_init(fmpz_mat_t window, const fmpz_mat_t mat, slong r1, slong c1, slong r2, slong c2) - void fmpz_mat_window_clear(fmpz_mat_t window) - void fmpz_mat_randbits(fmpz_mat_t mat, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_mat_randtest(fmpz_mat_t mat, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_mat_randintrel(fmpz_mat_t mat, flint_rand_t state, flint_bitcnt_t bits) - void fmpz_mat_randsimdioph(fmpz_mat_t mat, flint_rand_t state, flint_bitcnt_t bits, flint_bitcnt_t bits2) - void fmpz_mat_randntrulike(fmpz_mat_t mat, flint_rand_t state, flint_bitcnt_t bits, ulong q) - void fmpz_mat_randntrulike2(fmpz_mat_t mat, flint_rand_t state, flint_bitcnt_t bits, ulong q) - void fmpz_mat_randajtai(fmpz_mat_t mat, flint_rand_t state, double alpha) - int fmpz_mat_randpermdiag(fmpz_mat_t mat, flint_rand_t state, const fmpz_struct * diag, slong n) - void fmpz_mat_randrank(fmpz_mat_t mat, flint_rand_t state, slong rank, flint_bitcnt_t bits) - void fmpz_mat_randdet(fmpz_mat_t mat, flint_rand_t state, const fmpz_t det) - void fmpz_mat_randops(fmpz_mat_t mat, flint_rand_t state, slong count) - # int fmpz_mat_fprint(FILE * file, const fmpz_mat_t mat) - # int fmpz_mat_fprint_pretty(FILE * file, const fmpz_mat_t mat) - int fmpz_mat_print(const fmpz_mat_t mat) - int fmpz_mat_print_pretty(const fmpz_mat_t mat) - # int fmpz_mat_fread(FILE * file, fmpz_mat_t mat) - int fmpz_mat_read(fmpz_mat_t mat) - int fmpz_mat_equal(const fmpz_mat_t mat1, const fmpz_mat_t mat2) - int fmpz_mat_is_zero(const fmpz_mat_t mat) - int fmpz_mat_is_one(const fmpz_mat_t mat) - int fmpz_mat_is_empty(const fmpz_mat_t mat) - int fmpz_mat_is_square(const fmpz_mat_t mat) - int fmpz_mat_is_zero_row(const fmpz_mat_t mat, slong i) - int fmpz_mat_equal_col(fmpz_mat_t M, slong m, slong n) - int fmpz_mat_equal_row(fmpz_mat_t M, slong m, slong n) - void fmpz_mat_transpose(fmpz_mat_t B, const fmpz_mat_t A) - void fmpz_mat_concat_vertical(fmpz_mat_t res, const fmpz_mat_t mat1, const fmpz_mat_t mat2) - void fmpz_mat_concat_horizontal(fmpz_mat_t res, const fmpz_mat_t mat1, const fmpz_mat_t mat2) - void fmpz_mat_get_nmod_mat(nmod_mat_t Amod, const fmpz_mat_t A) - void fmpz_mat_set_nmod_mat(fmpz_mat_t A, const nmod_mat_t Amod) - void fmpz_mat_set_nmod_mat_unsigned(fmpz_mat_t A, const nmod_mat_t Amod) - void fmpz_mat_CRT_ui(fmpz_mat_t res, const fmpz_mat_t mat1, const fmpz_t m1, const nmod_mat_t mat2, int sign) - # void fmpz_mat_multi_mod_ui_precomp(nmod_mat_t * residues, slong nres, const fmpz_mat_t mat, const fmpz_comb_t comb, fmpz_comb_temp_t temp) - void fmpz_mat_multi_mod_ui(nmod_mat_t * residues, slong nres, const fmpz_mat_t mat) - # void fmpz_mat_multi_CRT_ui_precomp(fmpz_mat_t mat, nmod_mat_t * const residues, slong nres, const fmpz_comb_t comb, fmpz_comb_temp_t temp, int sign) - void fmpz_mat_multi_CRT_ui(fmpz_mat_t mat, nmod_mat_t * const residues, slong nres, int sign) - void fmpz_mat_add(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_sub(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_neg(fmpz_mat_t B, const fmpz_mat_t A) - void fmpz_mat_scalar_mul_si(fmpz_mat_t B, const fmpz_mat_t A, slong c) - void fmpz_mat_scalar_mul_ui(fmpz_mat_t B, const fmpz_mat_t A, ulong c) - void fmpz_mat_scalar_mul_fmpz(fmpz_mat_t B, const fmpz_mat_t A, const fmpz_t c) - void fmpz_mat_scalar_addmul_si(fmpz_mat_t B, const fmpz_mat_t A, slong c) - void fmpz_mat_scalar_addmul_ui(fmpz_mat_t B, const fmpz_mat_t A, ulong c) - void fmpz_mat_scalar_addmul_fmpz(fmpz_mat_t B, const fmpz_mat_t A, const fmpz_t c) - void fmpz_mat_scalar_submul_si(fmpz_mat_t B, const fmpz_mat_t A, slong c) - void fmpz_mat_scalar_submul_ui(fmpz_mat_t B, const fmpz_mat_t A, ulong c) - void fmpz_mat_scalar_submul_fmpz(fmpz_mat_t B, const fmpz_mat_t A, const fmpz_t c) - void fmpz_mat_scalar_addmul_nmod_mat_ui(fmpz_mat_t B, const nmod_mat_t A, ulong c) - void fmpz_mat_scalar_addmul_nmod_mat_fmpz(fmpz_mat_t B, const nmod_mat_t A, const fmpz_t c) - void fmpz_mat_scalar_divexact_si(fmpz_mat_t B, const fmpz_mat_t A, slong c) - void fmpz_mat_scalar_divexact_ui(fmpz_mat_t B, const fmpz_mat_t A, ulong c) - void fmpz_mat_scalar_divexact_fmpz(fmpz_mat_t B, const fmpz_mat_t A, const fmpz_t c) - void fmpz_mat_scalar_mul_2exp(fmpz_mat_t B, const fmpz_mat_t A, ulong exp) - void fmpz_mat_scalar_tdiv_q_2exp(fmpz_mat_t B, const fmpz_mat_t A, ulong exp) - void fmpz_mat_scalar_smod(fmpz_mat_t B, const fmpz_mat_t A, const fmpz_t P) - void fmpz_mat_mul(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_mul_classical(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_mul_waksman(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_mul_strassen(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void _fmpz_mat_mul_multi_mod(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B, int sign, flint_bitcnt_t bits) - void fmpz_mat_mul_multi_mod(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_mul_blas(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_mul_fft(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_sqr(fmpz_mat_t B, const fmpz_mat_t A) - void fmpz_mat_sqr_bodrato(fmpz_mat_t B, const fmpz_mat_t A) - void fmpz_mat_pow(fmpz_mat_t B, const fmpz_mat_t A, ulong e) - void _fmpz_mat_mul_small(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void _fmpz_mat_mul_double_word(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_mul_fmpz_vec(fmpz_struct * c, const fmpz_mat_t A, const fmpz_struct * b, slong blen) - void fmpz_mat_mul_fmpz_vec_ptr(fmpz_struct * const * c, const fmpz_mat_t A, const fmpz_struct * const * b, slong blen) - void fmpz_mat_fmpz_vec_mul(fmpz_struct * c, const fmpz_struct * a, slong alen, const fmpz_mat_t B) - void fmpz_mat_fmpz_vec_mul_ptr(fmpz_struct * const * c, const fmpz_struct * const * a, slong alen, const fmpz_mat_t B) - int fmpz_mat_inv(fmpz_mat_t Ainv, fmpz_t den, const fmpz_mat_t A) - void fmpz_mat_kronecker_product(fmpz_mat_t C, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_content(fmpz_t mat_gcd, const fmpz_mat_t A) - void fmpz_mat_trace(fmpz_t trace, const fmpz_mat_t mat) - void fmpz_mat_det(fmpz_t det, const fmpz_mat_t A) - void fmpz_mat_det_cofactor(fmpz_t det, const fmpz_mat_t A) - void fmpz_mat_det_bareiss(fmpz_t det, const fmpz_mat_t A) - void fmpz_mat_det_modular(fmpz_t det, const fmpz_mat_t A, int proved) - void fmpz_mat_det_modular_accelerated(fmpz_t det, const fmpz_mat_t A, int proved) - void fmpz_mat_det_modular_given_divisor(fmpz_t det, const fmpz_mat_t A, const fmpz_t d, int proved) - void fmpz_mat_det_bound(fmpz_t bound, const fmpz_mat_t A) - void fmpz_mat_det_bound_nonzero(fmpz_t bound, const fmpz_mat_t A) - void fmpz_mat_det_divisor(fmpz_t d, const fmpz_mat_t A) - void fmpz_mat_similarity(fmpz_mat_t A, slong r, fmpz_t d) - void _fmpz_mat_charpoly_berkowitz(fmpz_struct * cp, const fmpz_mat_t mat) - void fmpz_mat_charpoly_berkowitz(fmpz_poly_t cp, const fmpz_mat_t mat) - void _fmpz_mat_charpoly_modular(fmpz_struct * cp, const fmpz_mat_t mat) - void fmpz_mat_charpoly_modular(fmpz_poly_t cp, const fmpz_mat_t mat) - void _fmpz_mat_charpoly(fmpz_struct * cp, const fmpz_mat_t mat) - void fmpz_mat_charpoly(fmpz_poly_t cp, const fmpz_mat_t mat) - slong _fmpz_mat_minpoly_modular(fmpz_struct * cp, const fmpz_mat_t mat) - void fmpz_mat_minpoly_modular(fmpz_poly_t cp, const fmpz_mat_t mat) - slong _fmpz_mat_minpoly(fmpz_struct * cp, const fmpz_mat_t mat) - void fmpz_mat_minpoly(fmpz_poly_t cp, const fmpz_mat_t mat) - slong fmpz_mat_rank(const fmpz_mat_t A) - int fmpz_mat_col_partition(slong * part, fmpz_mat_t M, int short_circuit) - int fmpz_mat_solve(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_solve_fflu(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_solve_fflu_precomp(fmpz_mat_t X, const slong * perm, const fmpz_mat_t FFLU, const fmpz_mat_t B) - int fmpz_mat_solve_cramer(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - void fmpz_mat_solve_bound(fmpz_t N, fmpz_t D, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_solve_dixon(fmpz_mat_t X, fmpz_t M, const fmpz_mat_t A, const fmpz_mat_t B) - void _fmpz_mat_solve_dixon_den(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B, const nmod_mat_t Ainv, ulong p, const fmpz_t N, const fmpz_t D) - int fmpz_mat_solve_dixon_den(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_solve_multi_mod_den(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_can_solve_multi_mod_den(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_can_solve_fflu(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - int fmpz_mat_can_solve(fmpz_mat_t X, fmpz_t den, const fmpz_mat_t A, const fmpz_mat_t B) - slong fmpz_mat_find_pivot_any(const fmpz_mat_t mat, slong start_row, slong end_row, slong c) - slong fmpz_mat_fflu(fmpz_mat_t B, fmpz_t den, slong * perm, const fmpz_mat_t A, int rank_check) - slong fmpz_mat_rref(fmpz_mat_t B, fmpz_t den, const fmpz_mat_t A) - slong fmpz_mat_rref_fflu(fmpz_mat_t B, fmpz_t den, const fmpz_mat_t A) - slong fmpz_mat_rref_mul(fmpz_mat_t B, fmpz_t den, const fmpz_mat_t A) - int fmpz_mat_is_in_rref_with_rank(const fmpz_mat_t A, const fmpz_t den, slong rank) - void fmpz_mat_strong_echelon_form_mod(fmpz_mat_t A, const fmpz_t mod) - slong fmpz_mat_howell_form_mod(fmpz_mat_t A, const fmpz_t mod) - slong fmpz_mat_nullspace(fmpz_mat_t B, const fmpz_mat_t A) - slong fmpz_mat_rref_fraction_free(slong * perm, fmpz_mat_t B, fmpz_t den, const fmpz_mat_t A) - void fmpz_mat_hnf(fmpz_mat_t H, const fmpz_mat_t A) - void fmpz_mat_hnf_transform(fmpz_mat_t H, fmpz_mat_t U, const fmpz_mat_t A) - void fmpz_mat_hnf_classical(fmpz_mat_t H, const fmpz_mat_t A) - void fmpz_mat_hnf_xgcd(fmpz_mat_t H, const fmpz_mat_t A) - void fmpz_mat_hnf_modular(fmpz_mat_t H, const fmpz_mat_t A, const fmpz_t D) - void fmpz_mat_hnf_modular_eldiv(fmpz_mat_t A, const fmpz_t D) - void fmpz_mat_hnf_minors(fmpz_mat_t H, const fmpz_mat_t A) - void fmpz_mat_hnf_pernet_stein(fmpz_mat_t H, const fmpz_mat_t A, flint_rand_t state) - int fmpz_mat_is_in_hnf(const fmpz_mat_t A) - void fmpz_mat_snf(fmpz_mat_t S, const fmpz_mat_t A) - void fmpz_mat_snf_diagonal(fmpz_mat_t S, const fmpz_mat_t A) - void fmpz_mat_snf_kannan_bachem(fmpz_mat_t S, const fmpz_mat_t A) - void fmpz_mat_snf_iliopoulos(fmpz_mat_t S, const fmpz_mat_t A, const fmpz_t mod) - int fmpz_mat_is_in_snf(const fmpz_mat_t A) - void fmpz_mat_gram(fmpz_mat_t B, const fmpz_mat_t A) - int fmpz_mat_is_hadamard(const fmpz_mat_t H) - int fmpz_mat_hadamard(fmpz_mat_t H) - # int fmpz_mat_get_d_mat(d_mat_t B, const fmpz_mat_t A) - # int fmpz_mat_get_d_mat_transpose(d_mat_t B, const fmpz_mat_t A) - # void fmpz_mat_chol_d(d_mat_t R, const fmpz_mat_t A) - void fmpz_mat_is_spd(const fmpz_mat_t A) - int fmpz_mat_is_reduced(const fmpz_mat_t A, double delta, double eta) - int fmpz_mat_is_reduced_gram(const fmpz_mat_t A, double delta, double eta) - int fmpz_mat_is_reduced_with_removal(const fmpz_mat_t A, double delta, double eta, const fmpz_t gs_B, int newd) - int fmpz_mat_is_reduced_gram_with_removal(const fmpz_mat_t A, double delta, double eta, const fmpz_t gs_B, int newd) - void fmpz_mat_lll_original(fmpz_mat_t A, const fmpq_t delta, const fmpq_t eta) - void fmpz_mat_lll_storjohann(fmpz_mat_t A, const fmpq_t delta, const fmpq_t eta) diff --git a/src/flint/flintlib/functions/fmpz_mod.pxd b/src/flint/flintlib/functions/fmpz_mod.pxd deleted file mode 100644 index 1ab85519..00000000 --- a/src/flint/flintlib/functions/fmpz_mod.pxd +++ /dev/null @@ -1,35 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t, fmpz_mod_discrete_log_pohlig_hellman_t - - - -cdef extern from "flint/fmpz_mod.h": - void fmpz_mod_ctx_init(fmpz_mod_ctx_t ctx, const fmpz_t n) - void fmpz_mod_ctx_clear(fmpz_mod_ctx_t ctx) - void fmpz_mod_ctx_set_modulus(fmpz_mod_ctx_t ctx, const fmpz_t n) - void fmpz_mod_set_fmpz(fmpz_t a, const fmpz_t b, const fmpz_mod_ctx_t ctx) - int fmpz_mod_is_canonical(const fmpz_t a, const fmpz_mod_ctx_t ctx) - int fmpz_mod_is_one(const fmpz_t a, const fmpz_mod_ctx_t ctx) - void fmpz_mod_add(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_add_fmpz(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_add_ui(fmpz_t a, const fmpz_t b, ulong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_add_si(fmpz_t a, const fmpz_t b, slong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_sub(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_sub_fmpz(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_sub_ui(fmpz_t a, const fmpz_t b, ulong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_sub_si(fmpz_t a, const fmpz_t b, slong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_fmpz_sub(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_ui_sub(fmpz_t a, ulong b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_si_sub(fmpz_t a, slong b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_neg(fmpz_t a, const fmpz_t b, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mul(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_inv(fmpz_t a, const fmpz_t b, const fmpz_mod_ctx_t ctx) - int fmpz_mod_divides(fmpz_t a, const fmpz_t b, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_pow_ui(fmpz_t a, const fmpz_t b, ulong e, const fmpz_mod_ctx_t ctx) - int fmpz_mod_pow_fmpz(fmpz_t a, const fmpz_t b, const fmpz_t e, const fmpz_mod_ctx_t ctx) - void fmpz_mod_discrete_log_pohlig_hellman_init(fmpz_mod_discrete_log_pohlig_hellman_t L) - void fmpz_mod_discrete_log_pohlig_hellman_clear(fmpz_mod_discrete_log_pohlig_hellman_t L) - double fmpz_mod_discrete_log_pohlig_hellman_precompute_prime(fmpz_mod_discrete_log_pohlig_hellman_t L, const fmpz_t p) - const fmpz_struct * fmpz_mod_discrete_log_pohlig_hellman_primitive_root(fmpz_mod_discrete_log_pohlig_hellman_t L) - void fmpz_mod_discrete_log_pohlig_hellman_run(fmpz_t x, const fmpz_mod_discrete_log_pohlig_hellman_t L, const fmpz_t y) - int fmpz_next_smooth_prime(fmpz_t a, const fmpz_t b) diff --git a/src/flint/flintlib/functions/fmpz_mod_mat.pxd b/src/flint/flintlib/functions/fmpz_mod_mat.pxd deleted file mode 100644 index 92ed2a87..00000000 --- a/src/flint/flintlib/functions/fmpz_mod_mat.pxd +++ /dev/null @@ -1,65 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_mat_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t, fmpz_mod_mat_t -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t - -# unknown type thread_pool_handle - - -cdef extern from "flint/fmpz_mod_mat.h": - fmpz_struct * fmpz_mod_mat_entry(const fmpz_mod_mat_t mat, slong i, slong j) - void fmpz_mod_mat_set_entry(fmpz_mod_mat_t mat, slong i, slong j, const fmpz_t val, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_init(fmpz_mod_mat_t mat, slong rows, slong cols, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_init_set(fmpz_mod_mat_t mat, const fmpz_mod_mat_t src, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_clear(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_mat_nrows(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_mat_ncols(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_mat_set_mod(fmpz_mod_mat_t mat, const fmpz_t n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_one(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_zero(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_swap(fmpz_mod_mat_t mat1, fmpz_mod_mat_t mat2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_swap_entrywise(fmpz_mod_mat_t mat1, fmpz_mod_mat_t mat2, const fmpz_mod_ctx_t ctx) - int fmpz_mod_mat_is_empty(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - int fmpz_mod_mat_is_square(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_mat_reduce(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_randtest(fmpz_mod_mat_t mat, flint_rand_t state, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_window_init(fmpz_mod_mat_t window, const fmpz_mod_mat_t mat, slong r1, slong c1, slong r2, slong c2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_window_clear(fmpz_mod_mat_t window, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_concat_horizontal(fmpz_mod_mat_t res, const fmpz_mod_mat_t mat1, const fmpz_mod_mat_t mat2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_concat_vertical(fmpz_mod_mat_t res, const fmpz_mod_mat_t mat1, const fmpz_mod_mat_t mat2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_print_pretty(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - int fmpz_mod_mat_is_zero(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_set(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_transpose(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_set_fmpz_mat(fmpz_mod_mat_t A, const fmpz_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_get_fmpz_mat(fmpz_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_add(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_sub(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_neg(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_scalar_mul_si(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, slong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_scalar_mul_ui(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, ulong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_scalar_mul_fmpz(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_mul(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - # void _fmpz_mod_mat_mul_classical_threaded_pool_op(fmpz_mod_mat_t D, const fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, int op, thread_pool_handle * threads, slong num_threads, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_mat_mul_classical_threaded_op(fmpz_mod_mat_t D, const fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, int op, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_mul_classical_threaded(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_sqr(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_pow_ui(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, ulong e, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_mul_fmpz_vec(fmpz_struct * c, const fmpz_mod_mat_t A, const fmpz_struct * b, slong blen, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_mul_fmpz_vec_ptr(fmpz_struct * const * c, const fmpz_mod_mat_t A, const fmpz_struct * const * b, slong blen, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_fmpz_vec_mul(fmpz_struct * c, const fmpz_struct * a, slong alen, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_fmpz_vec_mul_ptr(fmpz_struct * const * c, const fmpz_struct * const * a, slong alen, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_trace(fmpz_t trace, const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_det(fmpz_t res, const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_mat_rref(fmpz_mod_mat_t res, const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_strong_echelon_form(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_mat_howell_form(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - int fmpz_mod_mat_inv(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_mat_lu(slong * P, fmpz_mod_mat_t A, int rank_check, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_solve_tril(fmpz_mod_mat_t X, const fmpz_mod_mat_t L, const fmpz_mod_mat_t B, int unit, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_solve_triu(fmpz_mod_mat_t X, const fmpz_mod_mat_t U, const fmpz_mod_mat_t B, int unit, const fmpz_mod_ctx_t ctx) - int fmpz_mod_mat_solve(fmpz_mod_mat_t X, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - int fmpz_mod_mat_can_solve(fmpz_mod_mat_t X, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_similarity(fmpz_mod_mat_t M, slong r, fmpz_t d, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_charpoly(fmpz_mod_poly_t p, const fmpz_mod_mat_t M, const fmpz_mod_ctx_t ctx) - void fmpz_mod_mat_minpoly(fmpz_mod_poly_t p, const fmpz_mod_mat_t M, const fmpz_mod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mod_mpoly.pxd b/src/flint/flintlib/functions/fmpz_mod_mpoly.pxd deleted file mode 100644 index 69e2b2fe..00000000 --- a/src/flint/flintlib/functions/fmpz_mod_mpoly.pxd +++ /dev/null @@ -1,155 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_poly_struct, fmpz_poly_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mpoly_ctx_t, fmpz_mod_mpoly_struct, fmpz_mod_mpoly_t -from flint.flintlib.types.mpoly cimport ordering_t - -# unknown type FILE -# unknown type fmpz_mod_mpoly_univar_t - - -cdef extern from "flint/fmpz_mod_mpoly.h": - void fmpz_mod_mpoly_ctx_init(fmpz_mod_mpoly_ctx_t ctx, slong nvars, const ordering_t ord, const fmpz_t p) - slong fmpz_mod_mpoly_ctx_nvars(const fmpz_mod_mpoly_ctx_t ctx) - ordering_t fmpz_mod_mpoly_ctx_ord(const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_ctx_get_modulus(fmpz_t n, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_ctx_clear(fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_init(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_init2(fmpz_mod_mpoly_t A, slong alloc, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_init3(fmpz_mod_mpoly_t A, slong alloc, flint_bitcnt_t bits, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_clear(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - char * fmpz_mod_mpoly_get_str_pretty(const fmpz_mod_mpoly_t A, const char ** x, const fmpz_mod_mpoly_ctx_t ctx) - # int fmpz_mod_mpoly_fprint_pretty(FILE * file, const fmpz_mod_mpoly_t A, const char ** x, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_print_pretty(const fmpz_mod_mpoly_t A, const char ** x, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_set_str_pretty(fmpz_mod_mpoly_t A, const char * str, const char ** x, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_gen(fmpz_mod_mpoly_t A, slong var, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_is_gen(const fmpz_mod_mpoly_t A, slong var, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_equal(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_swap(fmpz_mod_mpoly_t poly1, fmpz_mod_mpoly_t poly2, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_is_fmpz(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_fmpz(fmpz_t c, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_fmpz(fmpz_mod_mpoly_t A, const fmpz_t c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_ui(fmpz_mod_mpoly_t A, ulong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_si(fmpz_mod_mpoly_t A, slong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_zero(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_one(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_equal_fmpz(const fmpz_mod_mpoly_t A, const fmpz_t c, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_equal_ui(const fmpz_mod_mpoly_t A, ulong c, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_equal_si(const fmpz_mod_mpoly_t A, slong c, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_is_zero(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_is_one(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_degrees_fit_si(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_degrees_fmpz(fmpz_struct ** degs, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_degrees_si(slong * degs, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_degree_fmpz(fmpz_t deg, const fmpz_mod_mpoly_t A, slong var, const fmpz_mod_mpoly_ctx_t ctx) - slong fmpz_mod_mpoly_degree_si(const fmpz_mod_mpoly_t A, slong var, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_total_degree_fits_si(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_total_degree_fmpz(fmpz_t tdeg, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - slong fmpz_mod_mpoly_total_degree_si(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_used_vars(int * used, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_coeff_fmpz_monomial(fmpz_t c, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t M, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_fmpz_monomial(fmpz_mod_mpoly_t A, const fmpz_t c, const fmpz_mod_mpoly_t M, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_coeff_fmpz_fmpz(fmpz_t c, const fmpz_mod_mpoly_t A, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_coeff_fmpz_ui(fmpz_t c, const fmpz_mod_mpoly_t A, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_fmpz_fmpz(fmpz_mod_mpoly_t A, const fmpz_t c, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_ui_fmpz(fmpz_mod_mpoly_t A, ulong c, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_si_fmpz(fmpz_mod_mpoly_t A, slong c, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_fmpz_ui(fmpz_mod_mpoly_t A, const fmpz_t c, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_ui_ui(fmpz_mod_mpoly_t A, ulong c, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_coeff_si_ui(fmpz_mod_mpoly_t A, slong c, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_coeff_vars_ui(fmpz_mod_mpoly_t C, const fmpz_mod_mpoly_t A, const slong * vars, const ulong * exps, slong length, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_cmp(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_is_canonical(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - slong fmpz_mod_mpoly_length(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_resize(fmpz_mod_mpoly_t A, slong new_length, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_term_coeff_fmpz(fmpz_t c, const fmpz_mod_mpoly_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_term_coeff_fmpz(fmpz_mod_mpoly_t A, slong i, const fmpz_t c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_term_coeff_ui(fmpz_mod_mpoly_t A, slong i, ulong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_term_coeff_si(fmpz_mod_mpoly_t A, slong i, slong c, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_term_exp_fits_si(const fmpz_mod_mpoly_t poly, slong i, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_term_exp_fits_ui(const fmpz_mod_mpoly_t poly, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_term_exp_fmpz(fmpz_struct ** exp, const fmpz_mod_mpoly_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_term_exp_ui(ulong * exp, const fmpz_mod_mpoly_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_term_exp_si(slong * exp, const fmpz_mod_mpoly_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - ulong fmpz_mod_mpoly_get_term_var_exp_ui(const fmpz_mod_mpoly_t A, slong i, slong var, const fmpz_mod_mpoly_ctx_t ctx) - slong fmpz_mod_mpoly_get_term_var_exp_si(const fmpz_mod_mpoly_t A, slong i, slong var, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_term_exp_fmpz(fmpz_mod_mpoly_t A, slong i, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_set_term_exp_ui(fmpz_mod_mpoly_t A, slong i, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_term(fmpz_mod_mpoly_t M, const fmpz_mod_mpoly_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_get_term_monomial(fmpz_mod_mpoly_t M, const fmpz_mod_mpoly_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_fmpz_fmpz(fmpz_mod_mpoly_t A, const fmpz_t c, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_fmpz_ffmpz(fmpz_mod_mpoly_t A, const fmpz_t c, const fmpz_struct * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_ui_fmpz(fmpz_mod_mpoly_t A, ulong c, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_ui_ffmpz(fmpz_mod_mpoly_t A, ulong c, const fmpz_struct * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_si_fmpz(fmpz_mod_mpoly_t A, slong c, fmpz_struct * const * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_si_ffmpz(fmpz_mod_mpoly_t A, slong c, const fmpz_struct * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_fmpz_ui(fmpz_mod_mpoly_t A, const fmpz_t c, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_ui_ui(fmpz_mod_mpoly_t A, ulong c, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_push_term_si_ui(fmpz_mod_mpoly_t A, slong c, const ulong * exp, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_sort_terms(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_combine_like_terms(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_reverse(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_randtest_bound(fmpz_mod_mpoly_t A, flint_rand_t state, slong length, ulong exp_bound, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_randtest_bounds(fmpz_mod_mpoly_t A, flint_rand_t state, slong length, ulong * exp_bounds, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_randtest_bits(fmpz_mod_mpoly_t A, flint_rand_t state, slong length, ulong exp_bits, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_add_fmpz(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_t c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_add_ui(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, ulong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_add_si(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, slong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_sub_fmpz(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_t c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_sub_ui(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, ulong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_sub_si(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, slong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_add(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_t C, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_sub(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_t C, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_neg(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_scalar_mul_fmpz(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_t c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_scalar_mul_ui(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, ulong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_scalar_mul_si(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, slong c, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_scalar_addmul_fmpz(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_t C, const fmpz_t d, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_make_monic(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_derivative(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, slong var, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_evaluate_all_fmpz(fmpz_t eval, const fmpz_mod_mpoly_t A, fmpz_struct * const * vals, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_evaluate_one_fmpz(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, slong var, const fmpz_t val, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_compose_fmpz_poly(fmpz_poly_t A, const fmpz_mod_mpoly_t B, fmpz_poly_struct * const * C, const fmpz_mod_mpoly_ctx_t ctxB) - int fmpz_mod_mpoly_compose_fmpz_mod_mpoly_geobucket(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, fmpz_mod_mpoly_struct * const * C, const fmpz_mod_mpoly_ctx_t ctxB, const fmpz_mod_mpoly_ctx_t ctxAC) - int fmpz_mod_mpoly_compose_fmpz_mod_mpoly_horner(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, fmpz_mod_mpoly_struct * const * C, const fmpz_mod_mpoly_ctx_t ctxB, const fmpz_mod_mpoly_ctx_t ctxAC) - int fmpz_mod_mpoly_compose_fmpz_mod_mpoly(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, fmpz_mod_mpoly_struct * const * C, const fmpz_mod_mpoly_ctx_t ctxB, const fmpz_mod_mpoly_ctx_t ctxAC) - void fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const slong * c, const fmpz_mod_mpoly_ctx_t ctxB, const fmpz_mod_mpoly_ctx_t ctxAC) - void fmpz_mod_mpoly_mul(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_t C, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_mul_johnson(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_t C, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_mul_dense(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_t C, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_pow_fmpz(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_t k, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_pow_ui(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, ulong k, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_divides(fmpz_mod_mpoly_t Q, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_div(fmpz_mod_mpoly_t Q, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_divrem(fmpz_mod_mpoly_t Q, fmpz_mod_mpoly_t R, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_divrem_ideal(fmpz_mod_mpoly_struct ** Q, fmpz_mod_mpoly_t R, const fmpz_mod_mpoly_t A, fmpz_mod_mpoly_struct * const * B, slong len, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_term_content(fmpz_mod_mpoly_t M, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_content_vars(fmpz_mod_mpoly_t g, const fmpz_mod_mpoly_t A, slong * vars, slong vars_length, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd(fmpz_mod_mpoly_t G, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd_cofactors(fmpz_mod_mpoly_t G, fmpz_mod_mpoly_t Abar, fmpz_mod_mpoly_t Bbar, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd_brown(fmpz_mod_mpoly_t G, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd_hensel(fmpz_mod_mpoly_t G, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd_subresultant(fmpz_mod_mpoly_t G, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd_zippel(fmpz_mod_mpoly_t G, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_gcd_zippel2(fmpz_mod_mpoly_t G, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_resultant(fmpz_mod_mpoly_t R, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, slong var, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_discriminant(fmpz_mod_mpoly_t D, const fmpz_mod_mpoly_t A, slong var, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_sqrt(fmpz_mod_mpoly_t Q, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_is_square(const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_quadratic_root(fmpz_mod_mpoly_t Q, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_univar_init(fmpz_mod_mpoly_univar_t A, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_univar_clear(fmpz_mod_mpoly_univar_t A, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_univar_swap(fmpz_mod_mpoly_univar_t A, fmpz_mod_mpoly_univar_t B, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_to_univar(fmpz_mod_mpoly_univar_t A, const fmpz_mod_mpoly_t B, slong var, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_from_univar(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_univar_t B, slong var, const fmpz_mod_mpoly_ctx_t ctx) - # int fmpz_mod_mpoly_univar_degree_fits_si(const fmpz_mod_mpoly_univar_t A, const fmpz_mod_mpoly_ctx_t ctx) - # slong fmpz_mod_mpoly_univar_length(const fmpz_mod_mpoly_univar_t A, const fmpz_mod_mpoly_ctx_t ctx) - # slong fmpz_mod_mpoly_univar_get_term_exp_si(fmpz_mod_mpoly_univar_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_univar_get_term_coeff(fmpz_mod_mpoly_t c, const fmpz_mod_mpoly_univar_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_univar_swap_term_coeff(fmpz_mod_mpoly_t c, fmpz_mod_mpoly_univar_t A, slong i, const fmpz_mod_mpoly_ctx_t ctx) - # void fmpz_mod_mpoly_univar_set_coeff_ui(fmpz_mod_mpoly_univar_t Ax, ulong e, const fmpz_mod_mpoly_t c, const fmpz_mod_mpoly_ctx_t ctx) - # int fmpz_mod_mpoly_univar_resultant(fmpz_mod_mpoly_t R, const fmpz_mod_mpoly_univar_t Ax, const fmpz_mod_mpoly_univar_t Bx, const fmpz_mod_mpoly_ctx_t ctx) - # int fmpz_mod_mpoly_univar_discriminant(fmpz_mod_mpoly_t D, const fmpz_mod_mpoly_univar_t Ax, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_inflate(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_struct * shift, const fmpz_struct * stride, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_deflate(fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_t B, const fmpz_struct * shift, const fmpz_struct * stride, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_deflation(fmpz_struct * shift, fmpz_struct * stride, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mod_mpoly_factor.pxd b/src/flint/flintlib/functions/fmpz_mod_mpoly_factor.pxd deleted file mode 100644 index e8b4de6e..00000000 --- a/src/flint/flintlib/functions/fmpz_mod_mpoly_factor.pxd +++ /dev/null @@ -1,17 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_t, slong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mpoly_ctx_t, fmpz_mod_mpoly_factor_t, fmpz_mod_mpoly_t - - - -cdef extern from "flint/fmpz_mod_mpoly_factor.h": - void fmpz_mod_mpoly_factor_init(fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_factor_clear(fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_factor_swap(fmpz_mod_mpoly_factor_t f, fmpz_mod_mpoly_factor_t g, const fmpz_mod_mpoly_ctx_t ctx) - slong fmpz_mod_mpoly_factor_length(const fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_factor_get_constant_fmpz(fmpz_t c, const fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_factor_get_base(fmpz_mod_mpoly_t B, const fmpz_mod_mpoly_factor_t f, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_factor_swap_base(fmpz_mod_mpoly_t B, fmpz_mod_mpoly_factor_t f, slong i, const fmpz_mod_mpoly_ctx_t ctx) - slong fmpz_mod_mpoly_factor_get_exp_si(fmpz_mod_mpoly_factor_t f, slong i, const fmpz_mod_mpoly_ctx_t ctx) - void fmpz_mod_mpoly_factor_sort(fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_factor_squarefree(fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) - int fmpz_mod_mpoly_factor(fmpz_mod_mpoly_factor_t f, const fmpz_mod_mpoly_t A, const fmpz_mod_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mod_poly.pxd b/src/flint/flintlib/functions/fmpz_mod_poly.pxd deleted file mode 100644 index 4797123a..00000000 --- a/src/flint/flintlib/functions/fmpz_mod_poly.pxd +++ /dev/null @@ -1,242 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_mat_t, fmpz_poly_struct, fmpz_poly_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_berlekamp_massey_t, fmpz_mod_poly_frobenius_powers_2exp_t, fmpz_mod_poly_frobenius_powers_t, fmpz_mod_poly_radix_t, fmpz_mod_poly_struct, fmpz_mod_poly_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE -# unknown type mpz_t -# unknown type thread_pool_handle - - -cdef extern from "flint/fmpz_mod_poly.h": - void fmpz_mod_poly_init(fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_init2(fmpz_mod_poly_t poly, slong alloc, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_clear(fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_realloc(fmpz_mod_poly_t poly, slong alloc, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_fit_length(fmpz_mod_poly_t poly, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_normalise(fmpz_mod_poly_t poly) - void _fmpz_mod_poly_set_length(fmpz_mod_poly_t poly, slong len) - void fmpz_mod_poly_truncate(fmpz_mod_poly_t poly, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set_trunc(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest(fmpz_mod_poly_t f, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_irreducible(fmpz_mod_poly_t f, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_not_zero(fmpz_mod_poly_t f, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_monic(fmpz_mod_poly_t poly, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_monic_irreducible(fmpz_mod_poly_t poly, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_monic_primitive(fmpz_mod_poly_t poly, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_trinomial(fmpz_mod_poly_t poly, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_randtest_trinomial_irreducible(fmpz_mod_poly_t poly, flint_rand_t state, slong len, slong max_attempts, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_pentomial(fmpz_mod_poly_t poly, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_randtest_pentomial_irreducible(fmpz_mod_poly_t poly, flint_rand_t state, slong len, slong max_attempts, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_randtest_sparse_irreducible(fmpz_mod_poly_t poly, flint_rand_t state, slong len, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_poly_degree(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_poly_length(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - fmpz_struct * fmpz_mod_poly_lead(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set(fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_swap(fmpz_mod_poly_t poly1, fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_zero(fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_one(fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_zero_coeffs(fmpz_mod_poly_t poly, slong i, slong j, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_reverse(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set_ui(fmpz_mod_poly_t f, ulong c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set_fmpz(fmpz_mod_poly_t f, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set_fmpz_poly(fmpz_mod_poly_t f, const fmpz_poly_t g, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_get_fmpz_poly(fmpz_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_get_nmod_poly(nmod_poly_t f, const fmpz_mod_poly_t g) - void fmpz_mod_poly_set_nmod_poly(fmpz_mod_poly_t f, const nmod_poly_t g) - int fmpz_mod_poly_equal(const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_equal_trunc(const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, slong n, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_zero(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_one(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_gen(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set_coeff_fmpz(fmpz_mod_poly_t poly, slong n, const fmpz_t x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_set_coeff_ui(fmpz_mod_poly_t poly, slong n, ulong x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_get_coeff_fmpz(fmpz_t x, const fmpz_mod_poly_t poly, slong n, const fmpz_mod_ctx_t ctx) - # void fmpz_mod_poly_set_coeff_mpz(fmpz_mod_poly_t poly, slong n, const mpz_t x, const fmpz_mod_ctx_t ctx) - # void fmpz_mod_poly_get_coeff_mpz(mpz_t x, const fmpz_mod_poly_t poly, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_shift_left(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_mod_poly_shift_left(fmpz_mod_poly_t f, const fmpz_mod_poly_t g, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_shift_right(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_mod_poly_shift_right(fmpz_mod_poly_t f, const fmpz_mod_poly_t g, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_add(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_add(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_add_series(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_sub(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_sub(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_sub_series(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_neg(fmpz_struct * res, const fmpz_struct * poly, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_neg(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_scalar_mul_fmpz(fmpz_struct * res, const fmpz_struct * poly, slong len, const fmpz_t x, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_scalar_mul_ui(fmpz_struct * res, const fmpz_struct * poly, slong len, ulong x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_scalar_mul_fmpz(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_t x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_scalar_mul_ui(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, ulong x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_scalar_addmul_fmpz(fmpz_mod_poly_t rop, const fmpz_mod_poly_t op, const fmpz_t x, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_scalar_div_fmpz(fmpz_struct * res, const fmpz_struct * poly, slong len, const fmpz_t x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_scalar_div_fmpz(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_t x, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_mul(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_mul(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_mullow(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_mullow(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_sqr(fmpz_struct * res, const fmpz_struct * poly, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_sqr(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_mulhigh(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, slong start, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_mulmod(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_struct * f, slong lenf, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_mulmod(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_mulmod_preinv(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_struct * f, slong lenf, const fmpz_struct * finv, slong lenfinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_mulmod_preinv(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_poly_t f, const fmpz_mod_poly_t finv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_product_roots_fmpz_vec(fmpz_struct * poly, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_product_roots_fmpz_vec(fmpz_mod_poly_t poly, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_find_distinct_nonzero_roots(fmpz_struct * roots, const fmpz_mod_poly_t A, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_pow(fmpz_struct * rop, const fmpz_struct * op, slong len, ulong e, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_pow(fmpz_mod_poly_t rop, const fmpz_mod_poly_t op, ulong e, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_pow_trunc(fmpz_struct * res, const fmpz_struct * poly, ulong e, slong trunc, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_pow_trunc(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, ulong e, slong trunc, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_pow_trunc_binexp(fmpz_struct * res, const fmpz_struct * poly, ulong e, slong trunc, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_pow_trunc_binexp(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, ulong e, slong trunc, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_powmod_ui_binexp(fmpz_struct * res, const fmpz_struct * poly, ulong e, const fmpz_struct * f, slong lenf, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_powmod_ui_binexp(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, ulong e, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_powmod_ui_binexp_preinv(fmpz_struct * res, const fmpz_struct * poly, ulong e, const fmpz_struct * f, slong lenf, const fmpz_struct * finv, slong lenfinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_powmod_ui_binexp_preinv(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, ulong e, const fmpz_mod_poly_t f, const fmpz_mod_poly_t finv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_powmod_fmpz_binexp(fmpz_struct * res, const fmpz_struct * poly, const fmpz_t e, const fmpz_struct * f, slong lenf, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_powmod_fmpz_binexp(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_t e, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_powmod_fmpz_binexp_preinv(fmpz_struct * res, const fmpz_struct * poly, const fmpz_t e, const fmpz_struct * f, slong lenf, const fmpz_struct * finv, slong lenfinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_powmod_fmpz_binexp_preinv(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_t e, const fmpz_mod_poly_t f, const fmpz_mod_poly_t finv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_powmod_x_fmpz_preinv(fmpz_struct * res, const fmpz_t e, const fmpz_struct * f, slong lenf, const fmpz_struct * finv, slong lenfinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_powmod_x_fmpz_preinv(fmpz_mod_poly_t res, const fmpz_t e, const fmpz_mod_poly_t f, const fmpz_mod_poly_t finv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_powers_mod_preinv_naive(fmpz_struct ** res, const fmpz_struct * f, slong flen, slong n, const fmpz_struct * g, slong glen, const fmpz_struct * ginv, slong ginvlen, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_powers_mod_naive(fmpz_mod_poly_struct * res, const fmpz_mod_poly_t f, slong n, const fmpz_mod_poly_t g, const fmpz_mod_ctx_t ctx) - # void _fmpz_mod_poly_powers_mod_preinv_threaded_pool(fmpz_struct ** res, const fmpz_struct * f, slong flen, slong n, const fmpz_struct * g, slong glen, const fmpz_struct * ginv, slong ginvlen, const fmpz_mod_ctx_t p, thread_pool_handle * threads, slong num_threads) - void fmpz_mod_poly_powers_mod_bsgs(fmpz_mod_poly_struct * res, const fmpz_mod_poly_t f, slong n, const fmpz_mod_poly_t g, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_frobenius_powers_2exp_precomp(fmpz_mod_poly_frobenius_powers_2exp_t pow, const fmpz_mod_poly_t f, const fmpz_mod_poly_t finv, ulong m, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_frobenius_powers_2exp_clear(fmpz_mod_poly_frobenius_powers_2exp_t pow, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_frobenius_power(fmpz_mod_poly_t res, fmpz_mod_poly_frobenius_powers_2exp_t pow, const fmpz_mod_poly_t f, ulong m, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_frobenius_powers_precomp(fmpz_mod_poly_frobenius_powers_t pow, const fmpz_mod_poly_t f, const fmpz_mod_poly_t finv, ulong m, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_frobenius_powers_clear(fmpz_mod_poly_frobenius_powers_t pow, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_divrem_basecase(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_divrem_basecase(fmpz_mod_poly_t Q, fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_divrem_newton_n_preinv (fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_struct * Binv, slong lenBinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_divrem_newton_n_preinv(fmpz_mod_poly_t Q, fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_poly_t Binv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_div_newton_n_preinv (fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_struct * Binv, slong lenBinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_div_newton_n_preinv(fmpz_mod_poly_t Q, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_poly_t Binv, const fmpz_mod_ctx_t ctx) - ulong fmpz_mod_poly_remove(fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_rem_basecase(fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_rem_basecase(fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_div(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_div(fmpz_mod_poly_t Q, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_divrem(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_divrem(fmpz_mod_poly_t Q, fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_divrem_f(fmpz_t f, fmpz_mod_poly_t Q, fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_rem(fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_rem_f(fmpz_t f, fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_rem(fmpz_mod_poly_t R, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_divides_classical(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_divides_classical(fmpz_mod_poly_t Q, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_divides(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_divides(fmpz_mod_poly_t Q, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_inv_series(fmpz_struct * Qinv, const fmpz_struct * Q, slong Qlen, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_inv_series(fmpz_mod_poly_t Qinv, const fmpz_mod_poly_t Q, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_inv_series_f(fmpz_t f, fmpz_mod_poly_t Qinv, const fmpz_mod_poly_t Q, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_div_series(fmpz_struct * Q, const fmpz_struct * A, slong Alen, const fmpz_struct * B, slong Blen, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_div_series(fmpz_mod_poly_t Q, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_make_monic(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_make_monic_f(fmpz_t f, fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcd(fmpz_struct * G, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcd(fmpz_mod_poly_t G, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcd_euclidean_f(fmpz_t f, fmpz_struct * G, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcd_euclidean_f(fmpz_t f, fmpz_mod_poly_t G, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcd_f(fmpz_t f, fmpz_struct * G, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcd_f(fmpz_t f, fmpz_mod_poly_t G, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_hgcd(fmpz_struct **M, slong * lenM, fmpz_struct * A, slong * lenA, fmpz_struct * B, slong * lenB, const fmpz_struct * a, slong lena, const fmpz_struct * b, slong lenb, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_xgcd_euclidean_f(fmpz_t f, fmpz_struct * G, fmpz_struct * S, fmpz_struct * T, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_xgcd_euclidean_f(fmpz_t f, fmpz_mod_poly_t G, fmpz_mod_poly_t S, fmpz_mod_poly_t T, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_xgcd(fmpz_struct * G, fmpz_struct * S, fmpz_struct * T, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_xgcd(fmpz_mod_poly_t G, fmpz_mod_poly_t S, fmpz_mod_poly_t T, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_xgcd_f(fmpz_t f, fmpz_mod_poly_t G, fmpz_mod_poly_t S, fmpz_mod_poly_t T, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcdinv_euclidean(fmpz_struct * G, fmpz_struct * S, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invA, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcdinv_euclidean(fmpz_mod_poly_t G, fmpz_mod_poly_t S, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcdinv_euclidean_f(fmpz_t f, fmpz_struct * G, fmpz_struct * S, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_t invA, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcdinv_euclidean_f(fmpz_t f, fmpz_mod_poly_t G, fmpz_mod_poly_t S, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcdinv(fmpz_struct * G, fmpz_struct * S, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_gcdinv_f(fmpz_t f, fmpz_struct * G, fmpz_struct * S, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcdinv(fmpz_mod_poly_t G, fmpz_mod_poly_t S, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_gcdinv_f(fmpz_t f, fmpz_mod_poly_t G, fmpz_mod_poly_t S, const fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_invmod(fmpz_struct * A, const fmpz_struct * B, slong lenB, const fmpz_struct * P, slong lenP, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_invmod_f(fmpz_t f, fmpz_struct * A, const fmpz_struct * B, slong lenB, const fmpz_struct * P, slong lenP, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_invmod(fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_poly_t P, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_invmod_f(fmpz_t f, fmpz_mod_poly_t A, const fmpz_mod_poly_t B, const fmpz_mod_poly_t P, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_minpoly_bm(fmpz_struct * poly, const fmpz_struct * seq, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_minpoly_bm(fmpz_mod_poly_t poly, const fmpz_struct * seq, slong len, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_minpoly_hgcd(fmpz_struct * poly, const fmpz_struct * seq, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_minpoly_hgcd(fmpz_mod_poly_t poly, const fmpz_struct * seq, slong len, const fmpz_mod_ctx_t ctx) - slong _fmpz_mod_poly_minpoly(fmpz_struct * poly, const fmpz_struct * seq, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_minpoly(fmpz_mod_poly_t poly, const fmpz_struct * seq, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_resultant(fmpz_t res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_resultant(fmpz_t res, const fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_discriminant(fmpz_t d, const fmpz_struct * poly, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_discriminant(fmpz_t d, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_derivative(fmpz_struct * res, const fmpz_struct * poly, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_derivative(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_evaluate_fmpz(fmpz_t res, const fmpz_struct * poly, slong len, const fmpz_t a, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_evaluate_fmpz(fmpz_t res, const fmpz_mod_poly_t poly, const fmpz_t a, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_evaluate_fmpz_vec_iter(fmpz_struct * ys, const fmpz_struct * coeffs, slong len, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_evaluate_fmpz_vec_iter(fmpz_struct * ys, const fmpz_mod_poly_t poly, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_evaluate_fmpz_vec_fast_precomp(fmpz_struct * vs, const fmpz_struct * poly, slong plen, fmpz_poly_struct * const * tree, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_evaluate_fmpz_vec_fast(fmpz_struct * ys, const fmpz_struct * poly, slong plen, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_evaluate_fmpz_vec_fast(fmpz_struct * ys, const fmpz_mod_poly_t poly, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_evaluate_fmpz_vec(fmpz_struct * ys, const fmpz_struct * coeffs, slong len, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_evaluate_fmpz_vec(fmpz_struct * ys, const fmpz_mod_poly_t poly, const fmpz_struct * xs, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose(fmpz_mod_poly_t res, const fmpz_mod_poly_t poly1, const fmpz_mod_poly_t poly2, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_invsqrt_series(fmpz_struct * g, const fmpz_struct * h, slong hlen, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_invsqrt_series(fmpz_mod_poly_t g, const fmpz_mod_poly_t h, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_sqrt_series(fmpz_struct * g, const fmpz_struct * h, slong hlen, slong n, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_sqrt_series(fmpz_mod_poly_t g, const fmpz_mod_poly_t h, slong n, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_sqrt(fmpz_struct * s, const fmpz_struct * p, slong n, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_sqrt(fmpz_mod_poly_t s, const fmpz_mod_poly_t p, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose_mod(fmpz_struct * res, const fmpz_struct * f, slong lenf, const fmpz_struct * g, const fmpz_struct * h, slong lenh, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose_mod(fmpz_mod_poly_t res, const fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_poly_t h, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose_mod_horner(fmpz_struct * res, const fmpz_struct * f, slong lenf, const fmpz_struct * g, const fmpz_struct * h, slong lenh, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose_mod_horner(fmpz_mod_poly_t res, const fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_poly_t h, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose_mod_brent_kung(fmpz_struct * res, const fmpz_struct * f, slong len1, const fmpz_struct * g, const fmpz_struct * h, slong len3, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose_mod_brent_kung(fmpz_mod_poly_t res, const fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_poly_t h, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_reduce_matrix_mod_poly (fmpz_mat_t A, const fmpz_mat_t B, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_precompute_matrix_worker(void * arg_ptr) - void _fmpz_mod_poly_precompute_matrix (fmpz_mat_t A, const fmpz_struct * f, const fmpz_struct * g, slong leng, const fmpz_struct * ginv, slong lenginv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_precompute_matrix(fmpz_mat_t A, const fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_poly_t ginv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv_worker(void * arg_ptr) - void _fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv(fmpz_struct * res, const fmpz_struct * f, slong lenf, const fmpz_mat_t A, const fmpz_struct * h, slong lenh, const fmpz_struct * hinv, slong lenhinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose_mod_brent_kung_precomp_preinv(fmpz_mod_poly_t res, const fmpz_mod_poly_t f, const fmpz_mat_t A, const fmpz_mod_poly_t h, const fmpz_mod_poly_t hinv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose_mod_brent_kung_preinv(fmpz_struct * res, const fmpz_struct * f, slong lenf, const fmpz_struct * g, const fmpz_struct * h, slong lenh, const fmpz_struct * hinv, slong lenhinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose_mod_brent_kung_preinv(fmpz_mod_poly_t res, const fmpz_mod_poly_t f, const fmpz_mod_poly_t g, const fmpz_mod_poly_t h, const fmpz_mod_poly_t hinv, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_compose_mod_brent_kung_vec_preinv(fmpz_mod_poly_struct * res, const fmpz_mod_poly_struct * polys, slong len1, slong l, const fmpz_struct * g, slong glen, const fmpz_struct * h, slong lenh, const fmpz_struct * hinv, slong lenhinv, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_compose_mod_brent_kung_vec_preinv(fmpz_mod_poly_struct * res, const fmpz_mod_poly_struct * polys, slong len1, slong n, const fmpz_mod_poly_t g, const fmpz_mod_poly_t h, const fmpz_mod_poly_t hinv, const fmpz_mod_ctx_t ctx) - # void _fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool(fmpz_mod_poly_struct * res, const fmpz_mod_poly_struct * polys, slong lenpolys, slong l, const fmpz_struct * g, slong glen, const fmpz_struct * poly, slong len, const fmpz_struct * polyinv, slong leninv, const fmpz_mod_ctx_t ctx, thread_pool_handle * threads, slong num_threads) - # void fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool(fmpz_mod_poly_struct * res, const fmpz_mod_poly_struct * polys, slong len1, slong n, const fmpz_mod_poly_t g, const fmpz_mod_poly_t poly, const fmpz_mod_poly_t polyinv, const fmpz_mod_ctx_t ctx, thread_pool_handle * threads, slong num_threads) - void fmpz_mod_poly_compose_mod_brent_kung_vec_preinv_threaded(fmpz_mod_poly_struct * res, const fmpz_mod_poly_struct * polys, slong len1, slong n, const fmpz_mod_poly_t g, const fmpz_mod_poly_t poly, const fmpz_mod_poly_t polyinv, const fmpz_mod_ctx_t ctx) - fmpz_poly_struct ** _fmpz_mod_poly_tree_alloc(slong len) - void _fmpz_mod_poly_tree_free(fmpz_poly_struct ** tree, slong len) - void _fmpz_mod_poly_tree_build(fmpz_poly_struct ** tree, const fmpz_struct * roots, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_radix_init(fmpz_struct **Rpow, fmpz_struct **Rinv, const fmpz_struct * R, slong lenR, slong k, const fmpz_t invL, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_radix_init(fmpz_mod_poly_radix_t D, const fmpz_mod_poly_t R, slong degF, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_radix(fmpz_struct **B, const fmpz_struct * F, fmpz_struct **Rpow, fmpz_struct **Rinv, slong degR, slong k, slong i, fmpz_struct * W, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_radix(fmpz_mod_poly_struct **B, const fmpz_mod_poly_t F, const fmpz_mod_poly_radix_t D, const fmpz_mod_ctx_t ctx) - # int _fmpz_mod_poly_fprint(FILE * file, const fmpz_struct * poly, slong len, const fmpz_t p) - # int fmpz_mod_poly_fprint(FILE * file, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - # int fmpz_mod_poly_fprint_pretty(FILE * file, const fmpz_mod_poly_t poly, const char * x, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_print(const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_print_pretty(const fmpz_mod_poly_t poly, const char * x, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_inflate(fmpz_mod_poly_t result, const fmpz_mod_poly_t input, ulong inflation, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_deflate(fmpz_mod_poly_t result, const fmpz_mod_poly_t input, ulong deflation, const fmpz_mod_ctx_t ctx) - ulong fmpz_mod_poly_deflation(const fmpz_mod_poly_t input, const fmpz_mod_ctx_t ctx) - void fmpz_mod_berlekamp_massey_init(fmpz_mod_berlekamp_massey_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_berlekamp_massey_clear(fmpz_mod_berlekamp_massey_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_berlekamp_massey_start_over(fmpz_mod_berlekamp_massey_t B, const fmpz_mod_ctx_t ctx) - void fmpz_mod_berlekamp_massey_add_points(fmpz_mod_berlekamp_massey_t B, const fmpz_struct * a, slong count, const fmpz_mod_ctx_t ctx) - void fmpz_mod_berlekamp_massey_add_zeros(fmpz_mod_berlekamp_massey_t B, slong count, const fmpz_mod_ctx_t ctx) - void fmpz_mod_berlekamp_massey_add_point(fmpz_mod_berlekamp_massey_t B, const fmpz_t a, const fmpz_mod_ctx_t ctx) - int fmpz_mod_berlekamp_massey_reduce(fmpz_mod_berlekamp_massey_t B, const fmpz_mod_ctx_t ctx) - slong fmpz_mod_berlekamp_massey_point_count(const fmpz_mod_berlekamp_massey_t B) - const fmpz_struct * fmpz_mod_berlekamp_massey_points(const fmpz_mod_berlekamp_massey_t B) - const fmpz_mod_poly_struct * fmpz_mod_berlekamp_massey_V_poly(const fmpz_mod_berlekamp_massey_t B) - const fmpz_mod_poly_struct * fmpz_mod_berlekamp_massey_R_poly(const fmpz_mod_berlekamp_massey_t B) diff --git a/src/flint/flintlib/functions/fmpz_mod_poly_factor.pxd b/src/flint/flintlib/functions/fmpz_mod_poly_factor.pxd deleted file mode 100644 index 8a22bab8..00000000 --- a/src/flint/flintlib/functions/fmpz_mod_poly_factor.pxd +++ /dev/null @@ -1,37 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong -from flint.flintlib.types.fmpz cimport fmpz_factor_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t, fmpz_mod_poly_factor_t -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t - - - -cdef extern from "flint/fmpz_mod_poly_factor.h": - void fmpz_mod_poly_factor_init(fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_clear(fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_realloc(fmpz_mod_poly_factor_t fac, slong alloc, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_fit_length(fmpz_mod_poly_factor_t fac, slong len, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_set(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_print(const fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_insert(fmpz_mod_poly_factor_t fac, const fmpz_mod_poly_t poly, slong exp, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_concat(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_factor_t fac, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_pow(fmpz_mod_poly_factor_t fac, slong exp, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_irreducible(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_irreducible_ddf(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_irreducible_rabin(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_irreducible_rabin_f(fmpz_t r, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_is_squarefree(const fmpz_struct * f, slong len, const fmpz_mod_ctx_t ctx) - int _fmpz_mod_poly_is_squarefree_f(fmpz_t fac, const fmpz_struct * f, slong len, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_squarefree(const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_is_squarefree_f(fmpz_t fac, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_factor_equal_deg_prob(fmpz_mod_poly_t factor, flint_rand_t state, const fmpz_mod_poly_t pol, slong d, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_equal_deg(fmpz_mod_poly_factor_t factors, const fmpz_mod_poly_t pol, slong d, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_distinct_deg(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t poly, slong * const * degs, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_distinct_deg_threaded(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t poly, slong * const * degs, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_squarefree(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_cantor_zassenhaus(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_kaltofen_shoup(fmpz_mod_poly_factor_t res, const fmpz_mod_poly_t poly, const fmpz_mod_ctx_t ctx) - void fmpz_mod_poly_factor_berlekamp(fmpz_mod_poly_factor_t factors, const fmpz_mod_poly_t f, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_poly_interval_poly_worker(void * arg_ptr) - void fmpz_mod_poly_roots(fmpz_mod_poly_factor_t r, const fmpz_mod_poly_t f, int with_multiplicity, const fmpz_mod_ctx_t ctx) - int fmpz_mod_poly_roots_factored(fmpz_mod_poly_factor_t r, const fmpz_mod_poly_t f, int with_multiplicity, const fmpz_factor_t n, const fmpz_mod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mod_vec.pxd b/src/flint/flintlib/functions/fmpz_mod_vec.pxd deleted file mode 100644 index 4df28a52..00000000 --- a/src/flint/flintlib/functions/fmpz_mod_vec.pxd +++ /dev/null @@ -1,16 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_struct, fmpz_t, slong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t - - - -cdef extern from "flint/fmpz_mod_vec.h": - void _fmpz_mod_vec_set_fmpz_vec(fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_neg(fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_add(fmpz_struct * a, const fmpz_struct * b, const fmpz_struct * c, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_sub(fmpz_struct * a, const fmpz_struct * b, const fmpz_struct * c, slong n, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_scalar_mul_fmpz_mod(fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_scalar_addmul_fmpz_mod(fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_scalar_div_fmpz_mod(fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_t c, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_dot(fmpz_t d, const fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_dot_rev(fmpz_t d, const fmpz_struct * A, const fmpz_struct * B, slong len, const fmpz_mod_ctx_t ctx) - void _fmpz_mod_vec_mul(fmpz_struct * A, const fmpz_struct * B, const fmpz_struct * C, slong len, const fmpz_mod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mpoly.pxd b/src/flint/flintlib/functions/fmpz_mpoly.pxd deleted file mode 100644 index 783d47c7..00000000 --- a/src/flint/flintlib/functions/fmpz_mpoly.pxd +++ /dev/null @@ -1,217 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_mpoly_ctx_t, fmpz_mpoly_struct, fmpz_mpoly_t, fmpz_mpoly_vec_t, fmpz_poly_struct, fmpz_poly_t -from flint.flintlib.types.mpoly cimport ordering_t - -# unknown type FILE -# unknown type fmpz_mpoly_univar_t - -# .. macro:: fmpz_mpoly_vec_entry(vec, i) - -cdef extern from "flint/fmpz_mpoly.h": - void fmpz_mpoly_ctx_init(fmpz_mpoly_ctx_t ctx, slong nvars, const ordering_t ord) - slong fmpz_mpoly_ctx_nvars(const fmpz_mpoly_ctx_t ctx) - ordering_t fmpz_mpoly_ctx_ord(const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_ctx_clear(fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_init(fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_init2(fmpz_mpoly_t A, slong alloc, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_init3(fmpz_mpoly_t A, slong alloc, flint_bitcnt_t bits, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_fit_length(fmpz_mpoly_t A, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_fit_bits(fmpz_mpoly_t A, flint_bitcnt_t bits, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_realloc(fmpz_mpoly_t A, slong alloc, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_clear(fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - char * fmpz_mpoly_get_str_pretty(const fmpz_mpoly_t A, const char ** x, const fmpz_mpoly_ctx_t ctx) - # int fmpz_mpoly_fprint_pretty(FILE * file, const fmpz_mpoly_t A, const char ** x, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_print_pretty(const fmpz_mpoly_t A, const char ** x, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_set_str_pretty(fmpz_mpoly_t A, const char * str, const char ** x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_gen(fmpz_mpoly_t A, slong var, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_is_gen(const fmpz_mpoly_t A, slong var, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_equal(const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_swap(fmpz_mpoly_t poly1, fmpz_mpoly_t poly2, const fmpz_mpoly_ctx_t ctx) - int _fmpz_mpoly_fits_small(const fmpz_struct * poly, slong len) - slong fmpz_mpoly_max_bits(const fmpz_mpoly_t A) - int fmpz_mpoly_is_fmpz(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_fmpz(fmpz_t c, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_fmpz(fmpz_mpoly_t A, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_ui(fmpz_mpoly_t A, ulong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_si(fmpz_mpoly_t A, slong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_zero(fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_one(fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_equal_fmpz(const fmpz_mpoly_t A, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_equal_ui(const fmpz_mpoly_t A, ulong c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_equal_si(const fmpz_mpoly_t A, slong c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_is_zero(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_is_one(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_degrees_fit_si(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_degrees_fmpz(fmpz_struct ** degs, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_degrees_si(slong * degs, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_degree_fmpz(fmpz_t deg, const fmpz_mpoly_t A, slong var, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_degree_si(const fmpz_mpoly_t A, slong var, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_total_degree_fits_si(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_total_degree_fmpz(fmpz_t tdeg, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_total_degree_si(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_used_vars(int * used, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_coeff_fmpz_monomial(fmpz_t c, const fmpz_mpoly_t A, const fmpz_mpoly_t M, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_fmpz_monomial(fmpz_mpoly_t poly, const fmpz_t c, const fmpz_mpoly_t poly2, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_coeff_fmpz_fmpz(fmpz_t c, const fmpz_mpoly_t A, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - ulong fmpz_mpoly_get_coeff_ui_fmpz(const fmpz_mpoly_t A, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_get_coeff_si_fmpz(const fmpz_mpoly_t A, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_coeff_fmpz_ui(fmpz_t c, const fmpz_mpoly_t A, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - ulong fmpz_mpoly_get_coeff_ui_ui(const fmpz_mpoly_t A, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_get_coeff_si_ui(const fmpz_mpoly_t A, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_fmpz_fmpz(fmpz_mpoly_t A, const fmpz_t c, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_ui_fmpz(fmpz_mpoly_t A, ulong c, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_si_fmpz(fmpz_mpoly_t A, slong c, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_fmpz_ui(fmpz_mpoly_t A, const fmpz_t c, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_ui_ui(fmpz_mpoly_t A, ulong c, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_coeff_si_ui(fmpz_mpoly_t A, slong c, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_coeff_vars_ui(fmpz_mpoly_t C, const fmpz_mpoly_t A, const slong * vars, const ulong * exps, slong length, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_cmp(const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_is_fmpz_poly(const fmpz_mpoly_t A, slong var, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_get_fmpz_poly(fmpz_poly_t A, const fmpz_mpoly_t B, slong var, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_fmpz_poly(fmpz_mpoly_t A, const fmpz_poly_t B, slong var, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_gen_fmpz_poly(fmpz_mpoly_t A, slong var, const fmpz_poly_t B, const fmpz_mpoly_ctx_t ctx) - fmpz_struct * fmpz_mpoly_term_coeff_ref(fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_is_canonical(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_length(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_resize(fmpz_mpoly_t A, slong new_length, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_term_coeff_fmpz(fmpz_t c, const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - ulong fmpz_mpoly_get_term_coeff_ui(const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_get_term_coeff_si(const fmpz_mpoly_t poly, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_term_coeff_fmpz(fmpz_mpoly_t A, slong i, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_term_coeff_ui(fmpz_mpoly_t A, slong i, ulong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_term_coeff_si(fmpz_mpoly_t A, slong i, slong c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_term_exp_fits_si(const fmpz_mpoly_t poly, slong i, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_term_exp_fits_ui(const fmpz_mpoly_t poly, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_term_exp_fmpz(fmpz_struct ** exp, const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_term_exp_ui(ulong * exp, const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_term_exp_si(slong * exp, const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - ulong fmpz_mpoly_get_term_var_exp_ui(const fmpz_mpoly_t A, slong i, slong var, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_get_term_var_exp_si(const fmpz_mpoly_t A, slong i, slong var, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_term_exp_fmpz(fmpz_mpoly_t A, slong i, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_set_term_exp_ui(fmpz_mpoly_t A, slong i, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_term(fmpz_mpoly_t M, const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_get_term_monomial(fmpz_mpoly_t M, const fmpz_mpoly_t A, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_fmpz_fmpz(fmpz_mpoly_t A, const fmpz_t c, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_fmpz_ffmpz(fmpz_mpoly_t A, const fmpz_t c, const fmpz_struct * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_ui_fmpz(fmpz_mpoly_t A, ulong c, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_ui_ffmpz(fmpz_mpoly_t A, ulong c, const fmpz_struct * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_si_fmpz(fmpz_mpoly_t A, slong c, fmpz_struct * const * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_si_ffmpz(fmpz_mpoly_t A, slong c, const fmpz_struct * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_fmpz_ui(fmpz_mpoly_t A, const fmpz_t c, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_ui_ui(fmpz_mpoly_t A, ulong c, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_push_term_si_ui(fmpz_mpoly_t A, slong c, const ulong * exp, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_sort_terms(fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_combine_like_terms(fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_reverse(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_randtest_bound(fmpz_mpoly_t A, flint_rand_t state, slong length, ulong coeff_bits, ulong exp_bound, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_randtest_bounds(fmpz_mpoly_t A, flint_rand_t state, slong length, ulong coeff_bits, ulong * exp_bounds, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_randtest_bits(fmpz_mpoly_t A, flint_rand_t state, slong length, ulong coeff_bits, ulong exp_bits, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_add_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_add_ui(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_add_si(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_sub_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_sub_ui(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_sub_si(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_add(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_sub(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_neg(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_mul_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_mul_ui(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_mul_si(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_fmma(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t c, const fmpz_mpoly_t D, const fmpz_t e, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_divexact_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_divexact_ui(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_scalar_divexact_si(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_scalar_divides_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_scalar_divides_ui(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong c, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_scalar_divides_si(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong c, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_derivative(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong var, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_integral(fmpz_mpoly_t A, fmpz_t scale, const fmpz_mpoly_t B, slong var, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_evaluate_all_fmpz(fmpz_t ev, const fmpz_mpoly_t A, fmpz_struct * const * vals, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_evaluate_one_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, slong var, const fmpz_t val, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_compose_fmpz_poly(fmpz_poly_t A, const fmpz_mpoly_t B, fmpz_poly_struct * const * C, const fmpz_mpoly_ctx_t ctxB) - int fmpz_mpoly_compose_fmpz_mpoly_geobucket(fmpz_mpoly_t A, const fmpz_mpoly_t B, fmpz_mpoly_struct * const * C, const fmpz_mpoly_ctx_t ctxB, const fmpz_mpoly_ctx_t ctxAC) - int fmpz_mpoly_compose_fmpz_mpoly_horner(fmpz_mpoly_t A, const fmpz_mpoly_t B, fmpz_mpoly_struct * const * C, const fmpz_mpoly_ctx_t ctxB, const fmpz_mpoly_ctx_t ctxAC) - int fmpz_mpoly_compose_fmpz_mpoly(fmpz_mpoly_t A, const fmpz_mpoly_t B, fmpz_mpoly_struct * const * C, const fmpz_mpoly_ctx_t ctxB, const fmpz_mpoly_ctx_t ctxAC) - void fmpz_mpoly_compose_fmpz_mpoly_gen(fmpz_mpoly_t A, const fmpz_mpoly_t B, const slong * c, const fmpz_mpoly_ctx_t ctxB, const fmpz_mpoly_ctx_t ctxAC) - void fmpz_mpoly_mul(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_mul_threaded(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx, slong thread_limit) - void fmpz_mpoly_mul_johnson(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_mul_heap_threaded(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_mul_array(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_mul_array_threaded(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_mul_dense(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_t C, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_pow_fmpz(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_t k, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_pow_ui(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong k, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_divides(fmpz_mpoly_t Q, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_divrem(fmpz_mpoly_t Q, fmpz_mpoly_t R, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_quasidivrem(fmpz_t scale, fmpz_mpoly_t Q, fmpz_mpoly_t R, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_div(fmpz_mpoly_t Q, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_quasidiv(fmpz_t scale, fmpz_mpoly_t Q, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_divrem_ideal(fmpz_mpoly_struct ** Q, fmpz_mpoly_t R, const fmpz_mpoly_t A, fmpz_mpoly_struct * const * B, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_quasidivrem_ideal(fmpz_t scale, fmpz_mpoly_struct ** Q, fmpz_mpoly_t R, const fmpz_mpoly_t A, fmpz_mpoly_struct * const * B, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_term_content(fmpz_mpoly_t M, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_content_vars(fmpz_mpoly_t g, const fmpz_mpoly_t A, slong * vars, slong vars_length, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd(fmpz_mpoly_t G, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd_cofactors(fmpz_mpoly_t G, fmpz_mpoly_t Abar, fmpz_mpoly_t Bbar, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd_brown(fmpz_mpoly_t G, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd_hensel(fmpz_mpoly_t G, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd_subresultant(fmpz_mpoly_t G, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd_zippel(fmpz_mpoly_t G, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_gcd_zippel2(fmpz_mpoly_t G, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_resultant(fmpz_mpoly_t R, const fmpz_mpoly_t A, const fmpz_mpoly_t B, slong var, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_discriminant(fmpz_mpoly_t D, const fmpz_mpoly_t A, slong var, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_primitive_part(fmpz_mpoly_t res, const fmpz_mpoly_t f, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_sqrt_heap(fmpz_mpoly_t Q, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx, int check) - int fmpz_mpoly_sqrt(fmpz_mpoly_t q, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_is_square(const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_univar_init(fmpz_mpoly_univar_t A, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_univar_clear(fmpz_mpoly_univar_t A, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_univar_swap(fmpz_mpoly_univar_t A, fmpz_mpoly_univar_t B, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_to_univar(fmpz_mpoly_univar_t A, const fmpz_mpoly_t B, slong var, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_from_univar(fmpz_mpoly_t A, const fmpz_mpoly_univar_t B, slong var, const fmpz_mpoly_ctx_t ctx) - # int fmpz_mpoly_univar_degree_fits_si(const fmpz_mpoly_univar_t A, const fmpz_mpoly_ctx_t ctx) - # slong fmpz_mpoly_univar_length(const fmpz_mpoly_univar_t A, const fmpz_mpoly_ctx_t ctx) - # slong fmpz_mpoly_univar_get_term_exp_si(fmpz_mpoly_univar_t A, slong i, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_univar_get_term_coeff(fmpz_mpoly_t c, const fmpz_mpoly_univar_t A, slong i, const fmpz_mpoly_ctx_t ctx) - # void fmpz_mpoly_univar_swap_term_coeff(fmpz_mpoly_t c, fmpz_mpoly_univar_t A, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_inflate(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_struct * shift, const fmpz_struct * stride, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_deflate(fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_struct * shift, const fmpz_struct * stride, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_deflation(fmpz_struct * shift, fmpz_struct * stride, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_pow_fps(fmpz_mpoly_t A, const fmpz_mpoly_t B, ulong k, const fmpz_mpoly_ctx_t ctx) - slong _fmpz_mpoly_divides_array(fmpz_struct ** poly1, ulong ** exp1, slong * alloc, const fmpz_struct * poly2, const ulong * exp2, slong len2, const fmpz_struct * poly3, const ulong * exp3, slong len3, slong * mults, slong num, slong bits) - int fmpz_mpoly_divides_array(fmpz_mpoly_t poly1, const fmpz_mpoly_t poly2, const fmpz_mpoly_t poly3, const fmpz_mpoly_ctx_t ctx) - slong _fmpz_mpoly_divides_monagan_pearce(fmpz_struct ** poly1, ulong ** exp1, slong * alloc, const fmpz_struct * poly2, const ulong * exp2, slong len2, const fmpz_struct * poly3, const ulong * exp3, slong len3, ulong bits, slong N, const ulong * cmpmask) - int fmpz_mpoly_divides_monagan_pearce(fmpz_mpoly_t poly1, const fmpz_mpoly_t poly2, const fmpz_mpoly_t poly3, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_divides_heap_threaded(fmpz_mpoly_t Q, const fmpz_mpoly_t A, const fmpz_mpoly_t B, const fmpz_mpoly_ctx_t ctx) - slong _fmpz_mpoly_div_monagan_pearce(fmpz_struct ** polyq, ulong ** expq, slong * allocq, const fmpz_struct * poly2, const ulong * exp2, slong len2, const fmpz_struct * poly3, const ulong * exp3, slong len3, slong bits, slong N, const ulong * cmpmask) - void fmpz_mpoly_div_monagan_pearce(fmpz_mpoly_t polyq, const fmpz_mpoly_t poly2, const fmpz_mpoly_t poly3, const fmpz_mpoly_ctx_t ctx) - slong _fmpz_mpoly_divrem_monagan_pearce(slong * lenr, fmpz_struct ** polyq, ulong ** expq, slong * allocq, fmpz_struct ** polyr, ulong ** expr, slong * allocr, const fmpz_struct * poly2, const ulong * exp2, slong len2, const fmpz_struct * poly3, const ulong * exp3, slong len3, slong bits, slong N, const ulong * cmpmask) - void fmpz_mpoly_divrem_monagan_pearce(fmpz_mpoly_t q, fmpz_mpoly_t r, const fmpz_mpoly_t poly2, const fmpz_mpoly_t poly3, const fmpz_mpoly_ctx_t ctx) - slong _fmpz_mpoly_divrem_array(slong * lenr, fmpz_struct ** polyq, ulong ** expq, slong * allocq, fmpz_struct ** polyr, ulong ** expr, slong * allocr, const fmpz_struct * poly2, const ulong * exp2, slong len2, const fmpz_struct * poly3, const ulong * exp3, slong len3, slong * mults, slong num, slong bits) - int fmpz_mpoly_divrem_array(fmpz_mpoly_t q, fmpz_mpoly_t r, const fmpz_mpoly_t poly2, const fmpz_mpoly_t poly3, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_quasidivrem_heap(fmpz_t scale, fmpz_mpoly_t q, fmpz_mpoly_t r, const fmpz_mpoly_t poly2, const fmpz_mpoly_t poly3, const fmpz_mpoly_ctx_t ctx) - slong _fmpz_mpoly_divrem_ideal_monagan_pearce(fmpz_mpoly_struct ** polyq, fmpz_struct ** polyr, ulong ** expr, slong * allocr, const fmpz_struct * poly2, const ulong * exp2, slong len2, fmpz_mpoly_struct * const * poly3, ulong * const * exp3, slong len, slong N, slong bits, const fmpz_mpoly_ctx_t ctx, const ulong * cmpmask) - void fmpz_mpoly_divrem_ideal_monagan_pearce(fmpz_mpoly_struct ** q, fmpz_mpoly_t r, const fmpz_mpoly_t poly2, fmpz_mpoly_struct * const * poly3, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_init(fmpz_mpoly_vec_t vec, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_clear(fmpz_mpoly_vec_t vec, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_print(const fmpz_mpoly_vec_t vec, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_swap(fmpz_mpoly_vec_t x, fmpz_mpoly_vec_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_fit_length(fmpz_mpoly_vec_t vec, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_set(fmpz_mpoly_vec_t dest, const fmpz_mpoly_vec_t src, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_append(fmpz_mpoly_vec_t vec, const fmpz_mpoly_t f, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_vec_insert_unique(fmpz_mpoly_vec_t vec, const fmpz_mpoly_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_set_length(fmpz_mpoly_vec_t vec, slong len, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_randtest_not_zero(fmpz_mpoly_vec_t vec, flint_rand_t state, slong len, slong poly_len, slong bits, ulong exp_bound, fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_set_primitive_unique(fmpz_mpoly_vec_t res, const fmpz_mpoly_vec_t src, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_spoly(fmpz_mpoly_t res, const fmpz_mpoly_t f, const fmpz_mpoly_t g, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_reduction_primitive_part(fmpz_mpoly_t res, const fmpz_mpoly_t f, const fmpz_mpoly_vec_t vec, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_vec_is_groebner(const fmpz_mpoly_vec_t G, const fmpz_mpoly_vec_t F, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_vec_is_autoreduced(const fmpz_mpoly_vec_t F, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_autoreduction(fmpz_mpoly_vec_t H, const fmpz_mpoly_vec_t F, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_vec_autoreduction_groebner(fmpz_mpoly_vec_t H, const fmpz_mpoly_vec_t G, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_buchberger_naive(fmpz_mpoly_vec_t G, const fmpz_mpoly_vec_t F, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_buchberger_naive_with_limits(fmpz_mpoly_vec_t G, const fmpz_mpoly_vec_t F, slong ideal_len_limit, slong poly_len_limit, slong poly_bits_limit, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_symmetric_gens(fmpz_mpoly_t res, ulong k, slong * vars, slong n, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_symmetric(fmpz_mpoly_t res, ulong k, const fmpz_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mpoly_factor.pxd b/src/flint/flintlib/functions/fmpz_mpoly_factor.pxd deleted file mode 100644 index 63eb9c12..00000000 --- a/src/flint/flintlib/functions/fmpz_mpoly_factor.pxd +++ /dev/null @@ -1,19 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_t, slong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mpoly_ctx_t, fmpz_mpoly_factor_t, fmpz_mpoly_t - - - -cdef extern from "flint/fmpz_mpoly_factor.h": - void fmpz_mpoly_factor_init(fmpz_mpoly_factor_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_clear(fmpz_mpoly_factor_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_swap(fmpz_mpoly_factor_t f, fmpz_mpoly_factor_t g, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_factor_length(const fmpz_mpoly_factor_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_get_constant_fmpz(fmpz_t c, const fmpz_mpoly_factor_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_get_constant_fmpq(fmpq_t c, const fmpz_mpoly_factor_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_get_base(fmpz_mpoly_t B, const fmpz_mpoly_factor_t f, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_swap_base(fmpz_mpoly_t B, fmpz_mpoly_factor_t f, slong i, const fmpz_mpoly_ctx_t ctx) - slong fmpz_mpoly_factor_get_exp_si(fmpz_mpoly_factor_t f, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_factor_sort(fmpz_mpoly_factor_t f, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_factor_squarefree(fmpz_mpoly_factor_t f, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_factor(fmpz_mpoly_factor_t f, const fmpz_mpoly_t A, const fmpz_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_mpoly_q.pxd b/src/flint/flintlib/functions/fmpz_mpoly_q.pxd deleted file mode 100644 index aac2c55c..00000000 --- a/src/flint/flintlib/functions/fmpz_mpoly_q.pxd +++ /dev/null @@ -1,51 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mpoly_ctx_t, fmpz_mpoly_q_t, fmpz_mpoly_t - - -# .. macro:: fmpz_mpoly_q_numref(x) -# .. macro:: fmpz_mpoly_q_denref(x) - -cdef extern from "flint/fmpz_mpoly_q.h": - void fmpz_mpoly_q_init(fmpz_mpoly_q_t res, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_clear(fmpz_mpoly_q_t res, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_swap(fmpz_mpoly_q_t x, fmpz_mpoly_q_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_set(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_set_fmpq(fmpz_mpoly_q_t res, const fmpq_t x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_set_fmpz(fmpz_mpoly_q_t res, const fmpz_t x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_set_si(fmpz_mpoly_q_t res, slong x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_canonicalise(fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_q_is_canonical(const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_q_is_zero(const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_q_is_one(const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_used_vars(int * used, const fmpz_mpoly_q_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_used_vars_num(int * used, const fmpz_mpoly_q_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_used_vars_den(int * used, const fmpz_mpoly_q_t f, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_zero(fmpz_mpoly_q_t res, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_one(fmpz_mpoly_q_t res, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_gen(fmpz_mpoly_q_t res, slong i, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_print_pretty(const fmpz_mpoly_q_t f, const char ** x, const fmpz_mpoly_ctx_t ctx) - char * fmpz_mpoly_q_get_str_pretty(const fmpz_mpoly_q_t f, const char ** x, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_q_set_str_pretty(fmpz_mpoly_q_t res, const char * s, const char ** x, fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_randtest(fmpz_mpoly_q_t res, flint_rand_t state, slong length, ulong coeff_bits, slong exp_bound, const fmpz_mpoly_ctx_t ctx) - int fmpz_mpoly_q_equal(const fmpz_mpoly_q_t x, const fmpz_mpoly_q_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_neg(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_add(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_q_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_add_fmpq(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpq_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_add_fmpz(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_add_si(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, slong y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_sub(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_q_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_sub_fmpq(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpq_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_sub_fmpz(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_sub_si(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, slong y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_mul(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_q_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_mul_fmpq(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpq_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_mul_fmpz(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_mul_si(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, slong y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_div(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_q_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_div_fmpq(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpq_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_div_fmpz(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_t y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_div_si(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, slong y, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_inv(fmpz_mpoly_q_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) - void _fmpz_mpoly_q_content(fmpz_t num, fmpz_t den, const fmpz_mpoly_t xnum, const fmpz_mpoly_t xden, const fmpz_mpoly_ctx_t ctx) - void fmpz_mpoly_q_content(fmpq_t res, const fmpz_mpoly_q_t x, const fmpz_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fmpz_poly.pxd b/src/flint/flintlib/functions/fmpz_poly.pxd deleted file mode 100644 index 91782fd7..00000000 --- a/src/flint/flintlib/functions/fmpz_poly.pxd +++ /dev/null @@ -1,401 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_struct, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_poly_factor_t, fmpz_poly_t, fmpz_preinvn_t -from flint.flintlib.types.nmod cimport nmod_poly_factor_t, nmod_poly_t - -# unknown type FILE -# unknown type fmpz_poly_mul_precache_t -# unknown type fmpz_poly_powers_precomp_t - - -cdef extern from "flint/fmpz_poly.h": - void fmpz_poly_init(fmpz_poly_t poly) - void fmpz_poly_init2(fmpz_poly_t poly, slong alloc) - void fmpz_poly_realloc(fmpz_poly_t poly, slong alloc) - void fmpz_poly_fit_length(fmpz_poly_t poly, slong len) - void fmpz_poly_clear(fmpz_poly_t poly) - void _fmpz_poly_normalise(fmpz_poly_t poly) - void _fmpz_poly_set_length(fmpz_poly_t poly, slong newlen) - void fmpz_poly_attach_truncate(fmpz_poly_t trunc, const fmpz_poly_t poly, slong n) - void fmpz_poly_attach_shift(fmpz_poly_t trunc, const fmpz_poly_t poly, slong n) - slong fmpz_poly_length(const fmpz_poly_t poly) - slong fmpz_poly_degree(const fmpz_poly_t poly) - void fmpz_poly_set(fmpz_poly_t poly1, const fmpz_poly_t poly2) - void fmpz_poly_set_si(fmpz_poly_t poly, slong c) - void fmpz_poly_set_ui(fmpz_poly_t poly, ulong c) - void fmpz_poly_set_fmpz(fmpz_poly_t poly, const fmpz_t c) - int _fmpz_poly_set_str(fmpz_struct * poly, const char * str) - int fmpz_poly_set_str(fmpz_poly_t poly, const char * str) - char * _fmpz_poly_get_str(const fmpz_struct * poly, slong len) - char * fmpz_poly_get_str(const fmpz_poly_t poly) - char * _fmpz_poly_get_str_pretty(const fmpz_struct * poly, slong len, const char * x) - char * fmpz_poly_get_str_pretty(const fmpz_poly_t poly, const char * x) - void fmpz_poly_zero(fmpz_poly_t poly) - void fmpz_poly_one(fmpz_poly_t poly) - void fmpz_poly_zero_coeffs(fmpz_poly_t poly, slong i, slong j) - void fmpz_poly_swap(fmpz_poly_t poly1, fmpz_poly_t poly2) - void _fmpz_poly_reverse(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_reverse(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void fmpz_poly_truncate(fmpz_poly_t poly, slong newlen) - void fmpz_poly_set_trunc(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void fmpz_poly_randtest(fmpz_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_randtest_unsigned(fmpz_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_randtest_not_zero(fmpz_poly_t f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_randtest_no_real_root(fmpz_poly_t p, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_randtest_irreducible1(fmpz_poly_t pol, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_randtest_irreducible2(fmpz_poly_t pol, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_randtest_irreducible(fmpz_poly_t pol, flint_rand_t state, slong len, flint_bitcnt_t bits) - void fmpz_poly_get_coeff_fmpz(fmpz_t x, const fmpz_poly_t poly, slong n) - slong fmpz_poly_get_coeff_si(const fmpz_poly_t poly, slong n) - ulong fmpz_poly_get_coeff_ui(const fmpz_poly_t poly, slong n) - fmpz_struct * fmpz_poly_get_coeff_ptr(const fmpz_poly_t poly, slong n) - fmpz_struct * fmpz_poly_lead(const fmpz_poly_t poly) - void fmpz_poly_set_coeff_fmpz(fmpz_poly_t poly, slong n, const fmpz_t x) - void fmpz_poly_set_coeff_si(fmpz_poly_t poly, slong n, slong x) - void fmpz_poly_set_coeff_ui(fmpz_poly_t poly, slong n, ulong x) - int fmpz_poly_equal(const fmpz_poly_t poly1, const fmpz_poly_t poly2) - int fmpz_poly_equal_trunc(const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - int fmpz_poly_is_zero(const fmpz_poly_t poly) - int fmpz_poly_is_one(const fmpz_poly_t poly) - int fmpz_poly_is_unit(const fmpz_poly_t poly) - int fmpz_poly_is_gen(const fmpz_poly_t poly) - void _fmpz_poly_add(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_add(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void fmpz_poly_add_series(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_sub(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_sub(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void fmpz_poly_sub_series(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void fmpz_poly_neg(fmpz_poly_t res, const fmpz_poly_t poly) - void fmpz_poly_scalar_abs(fmpz_poly_t res, const fmpz_poly_t poly) - void fmpz_poly_scalar_mul_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) - void fmpz_poly_scalar_mul_si(fmpz_poly_t poly1, const fmpz_poly_t poly2, slong x) - void fmpz_poly_scalar_mul_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_mul_2exp(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong exp) - void fmpz_poly_scalar_addmul_si(fmpz_poly_t poly1, const fmpz_poly_t poly2, slong x) - void fmpz_poly_scalar_addmul_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_addmul_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) - void fmpz_poly_scalar_submul_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) - void fmpz_poly_scalar_fdiv_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) - void fmpz_poly_scalar_fdiv_si(fmpz_poly_t poly1, const fmpz_poly_t poly2, slong x) - void fmpz_poly_scalar_fdiv_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_fdiv_2exp(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_tdiv_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) - void fmpz_poly_scalar_tdiv_si(fmpz_poly_t poly1, const fmpz_poly_t poly2, slong x) - void fmpz_poly_scalar_tdiv_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_tdiv_2exp(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_divexact_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t x) - void fmpz_poly_scalar_divexact_si(fmpz_poly_t poly1, const fmpz_poly_t poly2, slong x) - void fmpz_poly_scalar_divexact_ui(fmpz_poly_t poly1, const fmpz_poly_t poly2, ulong x) - void fmpz_poly_scalar_mod_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t p) - void fmpz_poly_scalar_smod_fmpz(fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t p) - slong _fmpz_poly_remove_content_2exp(fmpz_struct * pol, slong len) - void _fmpz_poly_scale_2exp(fmpz_struct * pol, slong len, slong k) - void _fmpz_poly_bit_pack(nn_ptr arr, const fmpz_struct * poly, slong len, flint_bitcnt_t bit_size, int negate) - int _fmpz_poly_bit_unpack(fmpz_struct * poly, slong len, nn_srcptr arr, flint_bitcnt_t bit_size, int negate) - void _fmpz_poly_bit_unpack_unsigned(fmpz_struct * poly, slong len, nn_srcptr arr, flint_bitcnt_t bit_size) - void fmpz_poly_bit_pack(fmpz_t f, const fmpz_poly_t poly, flint_bitcnt_t bit_size) - void fmpz_poly_bit_unpack(fmpz_poly_t poly, const fmpz_t f, flint_bitcnt_t bit_size) - void fmpz_poly_bit_unpack_unsigned(fmpz_poly_t poly, const fmpz_t f, flint_bitcnt_t bit_size) - void _fmpz_poly_mul_classical(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_mul_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_mullow_classical(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n) - void fmpz_poly_mullow_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_mulhigh_classical(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong start) - void fmpz_poly_mulhigh_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong start) - void _fmpz_poly_mulmid_classical(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_mulmid_classical(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_mul_karatsuba(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_mul_karatsuba(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_mullow_karatsuba_n(fmpz_struct * res, const fmpz_struct * poly1, const fmpz_struct * poly2, slong n) - void fmpz_poly_mullow_karatsuba_n(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_mulhigh_karatsuba_n(fmpz_struct * res, const fmpz_struct * poly1, const fmpz_struct * poly2, slong len) - void fmpz_poly_mulhigh_karatsuba_n(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong len) - void _fmpz_poly_mul_KS(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_mul_KS(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_mullow_KS(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n) - void fmpz_poly_mullow_KS(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_mul_SS(fmpz_struct * output, const fmpz_struct * input1, slong length1, const fmpz_struct * input2, slong length2) - void fmpz_poly_mul_SS(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_mullow_SS(fmpz_struct * output, const fmpz_struct * input1, slong length1, const fmpz_struct * input2, slong length2, slong n) - void fmpz_poly_mullow_SS(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_mul(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_mul(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_mullow(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n) - void fmpz_poly_mullow(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void fmpz_poly_mulhigh_n(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_mulhigh(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong start) - # void fmpz_poly_mul_SS_precache_init(fmpz_poly_mul_precache_t pre, slong len1, slong bits1, const fmpz_poly_t poly2) - # void fmpz_poly_mul_precache_clear(fmpz_poly_mul_precache_t pre) - # void _fmpz_poly_mullow_SS_precache(fmpz_struct * output, const fmpz_struct * input1, slong len1, fmpz_poly_mul_precache_t pre, slong trunc) - # void fmpz_poly_mullow_SS_precache(fmpz_poly_t res, const fmpz_poly_t poly1, fmpz_poly_mul_precache_t pre, slong n) - # void fmpz_poly_mul_SS_precache(fmpz_poly_t res, const fmpz_poly_t poly1, fmpz_poly_mul_precache_t pre) - void _fmpz_poly_sqr_KS(fmpz_struct * rop, const fmpz_struct * op, slong len) - void fmpz_poly_sqr_KS(fmpz_poly_t rop, const fmpz_poly_t op) - void _fmpz_poly_sqr_karatsuba(fmpz_struct * rop, const fmpz_struct * op, slong len) - void fmpz_poly_sqr_karatsuba(fmpz_poly_t rop, const fmpz_poly_t op) - void _fmpz_poly_sqr_classical(fmpz_struct * rop, const fmpz_struct * op, slong len) - void fmpz_poly_sqr_classical(fmpz_poly_t rop, const fmpz_poly_t op) - void _fmpz_poly_sqr(fmpz_struct * rop, const fmpz_struct * op, slong len) - void fmpz_poly_sqr(fmpz_poly_t rop, const fmpz_poly_t op) - void _fmpz_poly_sqrlow_KS(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_sqrlow_KS(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void _fmpz_poly_sqrlow_karatsuba_n(fmpz_struct * res, const fmpz_struct * poly, slong n) - void fmpz_poly_sqrlow_karatsuba_n(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void _fmpz_poly_sqrlow_classical(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_sqrlow_classical(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void _fmpz_poly_sqrlow(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_sqrlow(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void _fmpz_poly_pow_multinomial(fmpz_struct * res, const fmpz_struct * poly, slong len, ulong e) - void fmpz_poly_pow_multinomial(fmpz_poly_t res, const fmpz_poly_t poly, ulong e) - void _fmpz_poly_pow_binomial(fmpz_struct * res, const fmpz_struct * poly, ulong e) - void fmpz_poly_pow_binomial(fmpz_poly_t res, const fmpz_poly_t poly, ulong e) - void _fmpz_poly_pow_addchains(fmpz_struct * res, const fmpz_struct * poly, slong len, const int * a, int n) - void fmpz_poly_pow_addchains(fmpz_poly_t res, const fmpz_poly_t poly, ulong e) - void _fmpz_poly_pow_binexp(fmpz_struct * res, const fmpz_struct * poly, slong len, ulong e) - void fmpz_poly_pow_binexp(fmpz_poly_t res, const fmpz_poly_t poly, ulong e) - void _fmpz_poly_pow_small(fmpz_struct * res, const fmpz_struct * poly, slong len, ulong e) - void _fmpz_poly_pow(fmpz_struct * res, const fmpz_struct * poly, slong len, ulong e) - void fmpz_poly_pow(fmpz_poly_t res, const fmpz_poly_t poly, ulong e) - void _fmpz_poly_pow_trunc(fmpz_struct * res, const fmpz_struct * poly, ulong e, slong n) - void fmpz_poly_pow_trunc(fmpz_poly_t res, const fmpz_poly_t poly, ulong e, slong n) - void _fmpz_poly_shift_left(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_shift_left(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void _fmpz_poly_shift_right(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_shift_right(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - ulong fmpz_poly_max_limbs(const fmpz_poly_t poly) - slong fmpz_poly_max_bits(const fmpz_poly_t poly) - void fmpz_poly_height(fmpz_t height, const fmpz_poly_t poly) - void _fmpz_poly_2norm(fmpz_t res, const fmpz_struct * poly, slong len) - void fmpz_poly_2norm(fmpz_t res, const fmpz_poly_t poly) - ulong _fmpz_poly_2norm_normalised_bits(const fmpz_struct * poly, slong len) - void _fmpz_poly_gcd_subresultant(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_gcd_subresultant(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - int _fmpz_poly_gcd_heuristic(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - int fmpz_poly_gcd_heuristic(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_gcd_modular(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_gcd_modular(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_gcd(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_gcd(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_xgcd_modular(fmpz_t r, fmpz_struct * s, fmpz_struct * t, const fmpz_struct * f, slong len1, const fmpz_struct * g, slong len2) - void fmpz_poly_xgcd_modular(fmpz_t r, fmpz_poly_t s, fmpz_poly_t t, const fmpz_poly_t f, const fmpz_poly_t g) - void _fmpz_poly_xgcd(fmpz_t r, fmpz_struct * s, fmpz_struct * t, const fmpz_struct * f, slong len1, const fmpz_struct * g, slong len2) - void fmpz_poly_xgcd(fmpz_t r, fmpz_poly_t s, fmpz_poly_t t, const fmpz_poly_t f, const fmpz_poly_t g) - void _fmpz_poly_lcm(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_lcm(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_resultant_modular(fmpz_t res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_resultant_modular(fmpz_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void fmpz_poly_resultant_modular_div(fmpz_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, const fmpz_t div, slong nbits) - void _fmpz_poly_resultant_euclidean(fmpz_t res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_resultant_euclidean(fmpz_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_resultant(fmpz_t res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_resultant(fmpz_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_discriminant(fmpz_t res, const fmpz_struct * poly, slong len) - void fmpz_poly_discriminant(fmpz_t res, const fmpz_poly_t poly) - void _fmpz_poly_content(fmpz_t res, const fmpz_struct * poly, slong len) - void fmpz_poly_content(fmpz_t res, const fmpz_poly_t poly) - void _fmpz_poly_primitive_part(fmpz_struct * res, const fmpz_struct * poly, slong len) - void fmpz_poly_primitive_part(fmpz_poly_t res, const fmpz_poly_t poly) - int _fmpz_poly_is_squarefree(const fmpz_struct * poly, slong len) - int fmpz_poly_is_squarefree(const fmpz_poly_t poly) - int _fmpz_poly_divrem_basecase(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, int exact) - void fmpz_poly_divrem_basecase(fmpz_poly_t Q, fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - int _fmpz_poly_divrem_divconquer_recursive(fmpz_struct * Q, fmpz_struct * BQ, fmpz_struct * W, const fmpz_struct * A, const fmpz_struct * B, slong lenB, int exact) - int _fmpz_poly_divrem_divconquer(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, int exact) - void fmpz_poly_divrem_divconquer(fmpz_poly_t Q, fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - int _fmpz_poly_divrem(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, int exact) - void fmpz_poly_divrem(fmpz_poly_t Q, fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - int _fmpz_poly_div_basecase(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, int exact) - void fmpz_poly_div_basecase(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B) - int _fmpz_poly_divremlow_divconquer_recursive(fmpz_struct * Q, fmpz_struct * BQ, const fmpz_struct * A, const fmpz_struct * B, slong lenB, int exact) - int _fmpz_poly_div_divconquer_recursive(fmpz_struct * Q, fmpz_struct * temp, const fmpz_struct * A, const fmpz_struct * B, slong lenB, int exact) - int _fmpz_poly_div_divconquer(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, int exact) - void fmpz_poly_div_divconquer(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B) - int _fmpz_poly_div(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, int exact) - void fmpz_poly_div(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_rem_basecase(fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpz_poly_rem_basecase(fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_rem(fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpz_poly_rem(fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_div_root(fmpz_struct * Q, const fmpz_struct * A, slong len, const fmpz_t c) - void fmpz_poly_div_root(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_t c) - void _fmpz_poly_divexact(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpz_poly_divexact(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_preinvert(fmpz_struct * B_inv, const fmpz_struct * B, slong n) - void fmpz_poly_preinvert(fmpz_poly_t B_inv, const fmpz_poly_t B) - void _fmpz_poly_div_preinv(fmpz_struct * Q, const fmpz_struct * A, slong len1, const fmpz_struct * B, const fmpz_struct * B_inv, slong len2) - void fmpz_poly_div_preinv(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B, const fmpz_poly_t B_inv) - void _fmpz_poly_divrem_preinv(fmpz_struct * Q, fmpz_struct * A, slong len1, const fmpz_struct * B, const fmpz_struct * B_inv, slong len2) - void fmpz_poly_divrem_preinv(fmpz_poly_t Q, fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B, const fmpz_poly_t B_inv) - fmpz_struct ** _fmpz_poly_powers_precompute(const fmpz_struct * B, slong len) - # void fmpz_poly_powers_precompute(fmpz_poly_powers_precomp_t pinv, fmpz_poly_t poly) - void _fmpz_poly_powers_clear(fmpz_struct ** powers, slong len) - # void fmpz_poly_powers_clear(fmpz_poly_powers_precomp_t pinv) - void _fmpz_poly_rem_powers_precomp(fmpz_struct * A, slong m, const fmpz_struct * B, slong n, fmpz_struct ** const powers) - # void fmpz_poly_rem_powers_precomp(fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B, const fmpz_poly_powers_precomp_t B_inv) - int _fmpz_poly_divides(fmpz_struct * Q, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - int fmpz_poly_divides(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B) - slong fmpz_poly_remove(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void fmpz_poly_divlow_smodp(fmpz_struct * res, const fmpz_poly_t f, const fmpz_poly_t g, const fmpz_t p, slong n) - void fmpz_poly_divhigh_smodp(fmpz_struct * res, const fmpz_poly_t f, const fmpz_poly_t g, const fmpz_t p, slong n) - void _fmpz_poly_inv_series_basecase(fmpz_struct * Qinv, const fmpz_struct * Q, slong Qlen, slong n) - void fmpz_poly_inv_series_basecase(fmpz_poly_t Qinv, const fmpz_poly_t Q, slong n) - void _fmpz_poly_inv_series_newton(fmpz_struct * Qinv, const fmpz_struct * Q, slong Qlen, slong n) - void fmpz_poly_inv_series_newton(fmpz_poly_t Qinv, const fmpz_poly_t Q, slong n) - void _fmpz_poly_inv_series(fmpz_struct * Qinv, const fmpz_struct * Q, slong Qlen, slong n) - void fmpz_poly_inv_series(fmpz_poly_t Qinv, const fmpz_poly_t Q, slong n) - void _fmpz_poly_div_series_basecase(fmpz_struct * Q, const fmpz_struct * A, slong Alen, const fmpz_struct * B, slong Blen, slong n) - void _fmpz_poly_div_series_divconquer(fmpz_struct * Q, const fmpz_struct * A, slong Alen, const fmpz_struct * B, slong Blen, slong n) - void _fmpz_poly_div_series(fmpz_struct * Q, const fmpz_struct * A, slong Alen, const fmpz_struct * B, slong Blen, slong n) - void fmpz_poly_div_series_basecase(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B, slong n) - void fmpz_poly_div_series_divconquer(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B, slong n) - void fmpz_poly_div_series(fmpz_poly_t Q, const fmpz_poly_t A, const fmpz_poly_t B, slong n) - void _fmpz_poly_pseudo_divrem_basecase(fmpz_struct * Q, fmpz_struct * R, ulong * d, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_preinvn_t inv) - void fmpz_poly_pseudo_divrem_basecase(fmpz_poly_t Q, fmpz_poly_t R, ulong * d, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_pseudo_divrem_divconquer(fmpz_struct * Q, fmpz_struct * R, ulong * d, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_preinvn_t inv) - void fmpz_poly_pseudo_divrem_divconquer(fmpz_poly_t Q, fmpz_poly_t R, ulong * d, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_pseudo_divrem_cohen(fmpz_struct * Q, fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpz_poly_pseudo_divrem_cohen(fmpz_poly_t Q, fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_pseudo_rem_cohen(fmpz_struct * R, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB) - void fmpz_poly_pseudo_rem_cohen(fmpz_poly_t R, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_pseudo_divrem(fmpz_struct * Q, fmpz_struct * R, ulong * d, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_preinvn_t inv) - void fmpz_poly_pseudo_divrem(fmpz_poly_t Q, fmpz_poly_t R, ulong * d, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_pseudo_div(fmpz_struct * Q, ulong * d, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_preinvn_t inv) - void fmpz_poly_pseudo_div(fmpz_poly_t Q, ulong * d, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_pseudo_rem(fmpz_struct * R, ulong * d, const fmpz_struct * A, slong lenA, const fmpz_struct * B, slong lenB, const fmpz_preinvn_t inv) - void fmpz_poly_pseudo_rem(fmpz_poly_t R, ulong * d, const fmpz_poly_t A, const fmpz_poly_t B) - void _fmpz_poly_derivative(fmpz_struct * rpoly, const fmpz_struct * poly, slong len) - void fmpz_poly_derivative(fmpz_poly_t res, const fmpz_poly_t poly) - void _fmpz_poly_nth_derivative(fmpz_struct * rpoly, const fmpz_struct * poly, ulong n, slong len) - void fmpz_poly_nth_derivative(fmpz_poly_t res, const fmpz_poly_t poly, ulong n) - void _fmpz_poly_evaluate_divconquer_fmpz(fmpz_t res, const fmpz_struct * poly, slong len, const fmpz_t a) - void fmpz_poly_evaluate_divconquer_fmpz(fmpz_t res, const fmpz_poly_t poly, const fmpz_t a) - void _fmpz_poly_evaluate_horner_fmpz(fmpz_t res, const fmpz_struct * f, slong len, const fmpz_t a) - void fmpz_poly_evaluate_horner_fmpz(fmpz_t res, const fmpz_poly_t f, const fmpz_t a) - void _fmpz_poly_evaluate_fmpz(fmpz_t res, const fmpz_struct * f, slong len, const fmpz_t a) - void fmpz_poly_evaluate_fmpz(fmpz_t res, const fmpz_poly_t f, const fmpz_t a) - void _fmpz_poly_evaluate_divconquer_fmpq(fmpz_t rnum, fmpz_t rden, const fmpz_struct * f, slong len, const fmpz_t anum, const fmpz_t aden) - void fmpz_poly_evaluate_divconquer_fmpq(fmpq_t res, const fmpz_poly_t f, const fmpq_t a) - void _fmpz_poly_evaluate_horner_fmpq(fmpz_t rnum, fmpz_t rden, const fmpz_struct * f, slong len, const fmpz_t anum, const fmpz_t aden) - void fmpz_poly_evaluate_horner_fmpq(fmpq_t res, const fmpz_poly_t f, const fmpq_t a) - void _fmpz_poly_evaluate_fmpq(fmpz_t rnum, fmpz_t rden, const fmpz_struct * f, slong len, const fmpz_t anum, const fmpz_t aden) - void fmpz_poly_evaluate_fmpq(fmpq_t res, const fmpz_poly_t f, const fmpq_t a) - ulong _fmpz_poly_evaluate_mod(const fmpz_struct * poly, slong len, ulong a, ulong n, ulong ninv) - ulong fmpz_poly_evaluate_mod(const fmpz_poly_t poly, ulong a, ulong n) - void fmpz_poly_evaluate_fmpz_vec(fmpz_struct * res, const fmpz_poly_t f, const fmpz_struct * a, slong n) - double _fmpz_poly_evaluate_horner_d(const fmpz_struct * poly, slong n, double d) - double fmpz_poly_evaluate_horner_d(const fmpz_poly_t poly, double d) - double _fmpz_poly_evaluate_horner_d_2exp(slong * exp, const fmpz_struct * poly, slong n, double d) - double fmpz_poly_evaluate_horner_d_2exp(slong * exp, const fmpz_poly_t poly, double d) - double _fmpz_poly_evaluate_horner_d_2exp2(slong * exp, const fmpz_struct * poly, slong n, double d, slong dexp) - void _fmpz_poly_monomial_to_newton(fmpz_struct * poly, const fmpz_struct * roots, slong n) - void _fmpz_poly_newton_to_monomial(fmpz_struct * poly, const fmpz_struct * roots, slong n) - void fmpz_poly_interpolate_fmpz_vec(fmpz_poly_t poly, const fmpz_struct * xs, const fmpz_struct * ys, slong n) - void _fmpz_poly_compose_horner(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_compose_horner(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_compose_divconquer(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_compose_divconquer(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void _fmpz_poly_compose(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2) - void fmpz_poly_compose(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2) - void fmpz_poly_inflate(fmpz_poly_t result, const fmpz_poly_t input, ulong inflation) - void fmpz_poly_deflate(fmpz_poly_t result, const fmpz_poly_t input, ulong deflation) - ulong fmpz_poly_deflation(const fmpz_poly_t input) - void _fmpz_poly_taylor_shift_horner(fmpz_struct * poly, const fmpz_t c, slong n) - void fmpz_poly_taylor_shift_horner(fmpz_poly_t g, const fmpz_poly_t f, const fmpz_t c) - void _fmpz_poly_taylor_shift_divconquer(fmpz_struct * poly, const fmpz_t c, slong n) - void fmpz_poly_taylor_shift_divconquer(fmpz_poly_t g, const fmpz_poly_t f, const fmpz_t c) - void _fmpz_poly_taylor_shift_multi_mod(fmpz_struct * poly, const fmpz_t c, slong n) - void fmpz_poly_taylor_shift_multi_mod(fmpz_poly_t g, const fmpz_poly_t f, const fmpz_t c) - void _fmpz_poly_taylor_shift(fmpz_struct * poly, const fmpz_t c, slong n) - void fmpz_poly_taylor_shift(fmpz_poly_t g, const fmpz_poly_t f, const fmpz_t c) - void _fmpz_poly_compose_series_horner(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n) - void fmpz_poly_compose_series_horner(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_compose_series_brent_kung(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n) - void fmpz_poly_compose_series_brent_kung(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_compose_series(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_struct * poly2, slong len2, slong n) - void fmpz_poly_compose_series(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_poly_t poly2, slong n) - void _fmpz_poly_revert_series(fmpz_struct * Qinv, const fmpz_struct * Q, slong Qlen, slong n) - void fmpz_poly_revert_series(fmpz_poly_t Qinv, const fmpz_poly_t Q, slong n) - int _fmpz_poly_sqrtrem_classical(fmpz_struct * res, fmpz_struct * r, const fmpz_struct * poly, slong len) - int fmpz_poly_sqrtrem_classical(fmpz_poly_t b, fmpz_poly_t r, const fmpz_poly_t a) - int _fmpz_poly_sqrtrem_divconquer(fmpz_struct * res, fmpz_struct * r, const fmpz_struct * poly, slong len, fmpz_struct * temp) - int fmpz_poly_sqrtrem_divconquer(fmpz_poly_t b, fmpz_poly_t r, const fmpz_poly_t a) - int _fmpz_poly_sqrt_classical(fmpz_struct * res, const fmpz_struct * poly, slong len, int exact) - int fmpz_poly_sqrt_classical(fmpz_poly_t b, const fmpz_poly_t a) - int _fmpz_poly_sqrt_KS(fmpz_struct * res, const fmpz_struct * poly, slong len) - int fmpz_poly_sqrt_KS(fmpz_poly_t b, const fmpz_poly_t a) - int _fmpz_poly_sqrt_divconquer(fmpz_struct * res, const fmpz_struct * poly, slong len, int exact) - int fmpz_poly_sqrt_divconquer(fmpz_poly_t b, const fmpz_poly_t a) - int _fmpz_poly_sqrt(fmpz_struct * res, const fmpz_struct * poly, slong len) - int fmpz_poly_sqrt(fmpz_poly_t b, const fmpz_poly_t a) - int _fmpz_poly_sqrt_series(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - int fmpz_poly_sqrt_series(fmpz_poly_t b, const fmpz_poly_t a, slong n) - void _fmpz_poly_power_sums_naive(fmpz_struct * res, const fmpz_struct * poly, slong len, slong n) - void fmpz_poly_power_sums_naive(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void fmpz_poly_power_sums(fmpz_poly_t res, const fmpz_poly_t poly, slong n) - void _fmpz_poly_power_sums_to_poly(fmpz_struct * res, const fmpz_struct * poly, slong len) - void fmpz_poly_power_sums_to_poly(fmpz_poly_t res, const fmpz_poly_t Q) - void _fmpz_poly_signature(slong * r1, slong * r2, const fmpz_struct * poly, slong len) - void fmpz_poly_signature(slong * r1, slong * r2, const fmpz_poly_t poly) - void fmpz_poly_hensel_build_tree(slong * link, fmpz_poly_t * v, fmpz_poly_t * w, const nmod_poly_factor_t fac) - void fmpz_poly_hensel_lift(fmpz_poly_t G, fmpz_poly_t H, fmpz_poly_t A, fmpz_poly_t B, const fmpz_poly_t f, const fmpz_poly_t g, const fmpz_poly_t h, const fmpz_poly_t a, const fmpz_poly_t b, const fmpz_t p, const fmpz_t p1) - void fmpz_poly_hensel_lift_without_inverse(fmpz_poly_t Gout, fmpz_poly_t Hout, const fmpz_poly_t f, const fmpz_poly_t g, const fmpz_poly_t h, const fmpz_poly_t a, const fmpz_poly_t b, const fmpz_t p, const fmpz_t p1) - void fmpz_poly_hensel_lift_only_inverse(fmpz_poly_t Aout, fmpz_poly_t Bout, const fmpz_poly_t G, const fmpz_poly_t H, const fmpz_poly_t a, const fmpz_poly_t b, const fmpz_t p, const fmpz_t p1) - void fmpz_poly_hensel_lift_tree_recursive(slong * link, fmpz_poly_t * v, fmpz_poly_t * w, fmpz_poly_t f, slong j, slong inv, const fmpz_t p0, const fmpz_t p1) - void fmpz_poly_hensel_lift_tree(slong * link, fmpz_poly_t * v, fmpz_poly_t * w, fmpz_poly_t f, slong r, const fmpz_t p, slong e0, slong e1, slong inv) - slong _fmpz_poly_hensel_start_lift(fmpz_poly_factor_t lifted_fac, slong * link, fmpz_poly_t * v, fmpz_poly_t * w, const fmpz_poly_t f, const nmod_poly_factor_t local_fac, slong N) - slong _fmpz_poly_hensel_continue_lift(fmpz_poly_factor_t lifted_fac, slong * link, fmpz_poly_t * v, fmpz_poly_t * w, const fmpz_poly_t f, slong prev, slong curr, slong N, const fmpz_t p) - void fmpz_poly_hensel_lift_once(fmpz_poly_factor_t lifted_fac, const fmpz_poly_t f, const nmod_poly_factor_t local_fac, slong N) - int _fmpz_poly_print(const fmpz_struct * poly, slong len) - int fmpz_poly_print(const fmpz_poly_t poly) - int _fmpz_poly_print_pretty(const fmpz_struct * poly, slong len, const char * x) - int fmpz_poly_print_pretty(const fmpz_poly_t poly, const char * x) - # int _fmpz_poly_fprint(FILE * file, const fmpz_struct * poly, slong len) - # int fmpz_poly_fprint(FILE * file, const fmpz_poly_t poly) - # int _fmpz_poly_fprint_pretty(FILE * file, const fmpz_struct * poly, slong len, const char * x) - # int fmpz_poly_fprint_pretty(FILE * file, const fmpz_poly_t poly, const char * x) - int fmpz_poly_read(fmpz_poly_t poly) - int fmpz_poly_read_pretty(fmpz_poly_t poly, char **x) - # int fmpz_poly_fread(FILE * file, fmpz_poly_t poly) - # int fmpz_poly_fread_pretty(FILE * file, fmpz_poly_t poly, char **x) - void fmpz_poly_get_nmod_poly(nmod_poly_t Amod, const fmpz_poly_t A) - void fmpz_poly_set_nmod_poly(fmpz_poly_t A, const nmod_poly_t Amod) - void fmpz_poly_set_nmod_poly_unsigned(fmpz_poly_t A, const nmod_poly_t Amod) - void _fmpz_poly_CRT_ui_precomp(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_t m1, nn_srcptr poly2, slong len2, ulong m2, ulong m2inv, fmpz_t m1m2, ulong c, int sign) - void _fmpz_poly_CRT_ui(fmpz_struct * res, const fmpz_struct * poly1, slong len1, const fmpz_t m1, nn_srcptr poly2, slong len2, ulong m2, ulong m2inv, int sign) - void fmpz_poly_CRT_ui(fmpz_poly_t res, const fmpz_poly_t poly1, const fmpz_t m, const nmod_poly_t poly2, int sign) - void _fmpz_poly_product_roots_fmpz_vec(fmpz_struct * poly, const fmpz_struct * xs, slong n) - void fmpz_poly_product_roots_fmpz_vec(fmpz_poly_t poly, const fmpz_struct * xs, slong n) - void _fmpz_poly_product_roots_fmpq_vec(fmpz_struct * poly, const fmpq_struct * xs, slong n) - void fmpz_poly_product_roots_fmpq_vec(fmpz_poly_t poly, const fmpq_struct * xs, slong n) - void _fmpz_poly_bound_roots(fmpz_t bound, const fmpz_struct * poly, slong len) - void fmpz_poly_bound_roots(fmpz_t bound, const fmpz_poly_t poly) - void _fmpz_poly_num_real_roots_sturm(slong * n_neg, slong * n_pos, const fmpz_struct * pol, slong len) - slong fmpz_poly_num_real_roots_sturm(const fmpz_poly_t pol) - slong _fmpz_poly_num_real_roots(const fmpz_struct * pol, slong len) - slong fmpz_poly_num_real_roots(const fmpz_poly_t pol) - void _fmpz_poly_cyclotomic(fmpz_struct * a, ulong n, nn_ptr factors, slong num_factors, ulong phi) - void fmpz_poly_cyclotomic(fmpz_poly_t poly, ulong n) - ulong _fmpz_poly_is_cyclotomic(const fmpz_struct * poly, slong len) - ulong fmpz_poly_is_cyclotomic(const fmpz_poly_t poly) - void _fmpz_poly_cos_minpoly(fmpz_struct * coeffs, ulong n) - void fmpz_poly_cos_minpoly(fmpz_poly_t poly, ulong n) - void _fmpz_poly_swinnerton_dyer(fmpz_struct * coeffs, ulong n) - void fmpz_poly_swinnerton_dyer(fmpz_poly_t poly, ulong n) - void _fmpz_poly_chebyshev_t(fmpz_struct * coeffs, ulong n) - void fmpz_poly_chebyshev_t(fmpz_poly_t poly, ulong n) - void _fmpz_poly_chebyshev_u(fmpz_struct * coeffs, ulong n) - void fmpz_poly_chebyshev_u(fmpz_poly_t poly, ulong n) - void _fmpz_poly_legendre_pt(fmpz_struct * coeffs, ulong n) - void fmpz_poly_legendre_pt(fmpz_poly_t poly, ulong n) - void _fmpz_poly_hermite_h(fmpz_struct * coeffs, ulong n) - void fmpz_poly_hermite_h(fmpz_poly_t poly, ulong n) - void _fmpz_poly_hermite_he(fmpz_struct * coeffs, ulong n) - void fmpz_poly_hermite_he(fmpz_poly_t poly, ulong n) - void _fmpz_poly_fibonacci(fmpz_struct * coeffs, ulong n) - void fmpz_poly_fibonacci(fmpz_poly_t poly, ulong n) - void fmpz_eulerian_polynomial(fmpz_poly_t res, ulong n) - void _fmpz_poly_eta_qexp(fmpz_struct * f, slong r, slong len) - void fmpz_poly_eta_qexp(fmpz_poly_t f, slong r, slong n) - void _fmpz_poly_theta_qexp(fmpz_struct * f, slong r, slong len) - void fmpz_poly_theta_qexp(fmpz_poly_t f, slong r, slong n) - void fmpz_poly_CLD_bound(fmpz_t res, const fmpz_poly_t f, slong n) diff --git a/src/flint/flintlib/functions/fmpz_poly_factor.pxd b/src/flint/flintlib/functions/fmpz_poly_factor.pxd deleted file mode 100644 index 26460b55..00000000 --- a/src/flint/flintlib/functions/fmpz_poly_factor.pxd +++ /dev/null @@ -1,22 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_t, slong -from flint.flintlib.types.fmpz cimport fmpz_poly_factor_t, fmpz_poly_t - - - -cdef extern from "flint/fmpz_poly_factor.h": - void fmpz_poly_factor_init(fmpz_poly_factor_t fac) - void fmpz_poly_factor_init2(fmpz_poly_factor_t fac, slong alloc) - void fmpz_poly_factor_realloc(fmpz_poly_factor_t fac, slong alloc) - void fmpz_poly_factor_fit_length(fmpz_poly_factor_t fac, slong len) - void fmpz_poly_factor_clear(fmpz_poly_factor_t fac) - void fmpz_poly_factor_set(fmpz_poly_factor_t res, const fmpz_poly_factor_t fac) - void fmpz_poly_factor_insert(fmpz_poly_factor_t fac, const fmpz_poly_t p, slong e) - void fmpz_poly_factor_concat(fmpz_poly_factor_t res, const fmpz_poly_factor_t fac) - void fmpz_poly_factor_print(const fmpz_poly_factor_t fac) - void fmpz_poly_factor_squarefree(fmpz_poly_factor_t fac, const fmpz_poly_t F) - void fmpz_poly_factor_zassenhaus_recombination(fmpz_poly_factor_t final_fac, const fmpz_poly_factor_t lifted_fac, const fmpz_poly_t F, const fmpz_t P, slong exp) - void _fmpz_poly_factor_zassenhaus(fmpz_poly_factor_t final_fac, slong exp, const fmpz_poly_t f, slong cutoff, int use_van_hoeij) - void fmpz_poly_factor_zassenhaus(fmpz_poly_factor_t final_fac, const fmpz_poly_t F) - void _fmpz_poly_factor_quadratic(fmpz_poly_factor_t fac, const fmpz_poly_t f, slong exp) - void _fmpz_poly_factor_cubic(fmpz_poly_factor_t fac, const fmpz_poly_t f, slong exp) - void fmpz_poly_factor(fmpz_poly_factor_t final_fac, const fmpz_poly_t F) diff --git a/src/flint/flintlib/functions/fmpz_vec.pxd b/src/flint/flintlib/functions/fmpz_vec.pxd deleted file mode 100644 index 9ec83eed..00000000 --- a/src/flint/flintlib/functions/fmpz_vec.pxd +++ /dev/null @@ -1,70 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, nmod_t, nn_ptr, nn_srcptr, slong, ulong - -# unknown type FILE - - -cdef extern from "flint/fmpz_vec.h": - fmpz_struct * _fmpz_vec_init(slong len) - void _fmpz_vec_clear(fmpz_struct * vec, slong len) - void _fmpz_vec_randtest(fmpz_struct * f, flint_rand_t state, slong len, flint_bitcnt_t bits) - void _fmpz_vec_randtest_unsigned(fmpz_struct * f, flint_rand_t state, slong len, flint_bitcnt_t bits) - slong _fmpz_vec_max_bits(const fmpz_struct * vec, slong len) - slong _fmpz_vec_max_bits_ref(const fmpz_struct * vec, slong len) - void _fmpz_vec_sum_max_bits(slong * sumabs, slong * maxabs, const fmpz_struct * vec, slong len) - slong _fmpz_vec_max_limbs(const fmpz_struct * vec, slong len) - void _fmpz_vec_height(fmpz_t height, const fmpz_struct * vec, slong len) - slong _fmpz_vec_height_index(const fmpz_struct * vec, slong len) - # int _fmpz_vec_fread(FILE * file, fmpz_struct ** vec, slong * len) - int _fmpz_vec_read(fmpz_struct ** vec, slong * len) - # int _fmpz_vec_fprint(FILE * file, const fmpz_struct * vec, slong len) - int _fmpz_vec_print(const fmpz_struct * vec, slong len) - void _fmpz_vec_get_nmod_vec(nn_ptr res, const fmpz_struct * poly, slong len, nmod_t mod) - void _fmpz_vec_set_nmod_vec(fmpz_struct * res, nn_srcptr poly, slong len, nmod_t mod) - void _fmpz_vec_get_fft(ulong ** coeffs_f, const fmpz_struct * coeffs_m, slong l, slong length) - void _fmpz_vec_set_fft(fmpz_struct * coeffs_m, slong length, const nn_ptr * coeffs_f, slong limbs, slong sign) - slong _fmpz_vec_get_d_vec_2exp(double * appv, const fmpz_struct * vec, slong len) - void _fmpz_vec_set(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2) - void _fmpz_vec_swap(fmpz_struct * vec1, fmpz_struct * vec2, slong len2) - void _fmpz_vec_zero(fmpz_struct * vec, slong len) - void _fmpz_vec_neg(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2) - void _fmpz_vec_scalar_abs(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2) - int _fmpz_vec_equal(const fmpz_struct * vec1, const fmpz_struct * vec2, slong len) - int _fmpz_vec_is_zero(const fmpz_struct * vec, slong len) - void _fmpz_vec_max(fmpz_struct * vec1, const fmpz_struct * vec2, const fmpz_struct * vec3, slong len) - void _fmpz_vec_max_inplace(fmpz_struct * vec1, const fmpz_struct * vec2, slong len) - void _fmpz_vec_sort(fmpz_struct * vec, slong len) - void _fmpz_vec_add(fmpz_struct * res, const fmpz_struct * vec1, const fmpz_struct * vec2, slong len2) - void _fmpz_vec_sub(fmpz_struct * res, const fmpz_struct * vec1, const fmpz_struct * vec2, slong len2) - void _fmpz_vec_scalar_mul_fmpz(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, const fmpz_t x) - void _fmpz_vec_scalar_mul_si(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c) - void _fmpz_vec_scalar_mul_ui(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong c) - void _fmpz_vec_scalar_mul_2exp(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong exp) - void _fmpz_vec_scalar_divexact_fmpz(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, const fmpz_t x) - void _fmpz_vec_scalar_divexact_si(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c) - void _fmpz_vec_scalar_divexact_ui(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong c) - void _fmpz_vec_scalar_fdiv_q_fmpz(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, const fmpz_t c) - void _fmpz_vec_scalar_fdiv_q_si(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c) - void _fmpz_vec_scalar_fdiv_q_ui(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong c) - void _fmpz_vec_scalar_fdiv_q_2exp(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong exp) - void _fmpz_vec_scalar_fdiv_r_2exp(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong exp) - void _fmpz_vec_scalar_tdiv_q_fmpz(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, const fmpz_t c) - void _fmpz_vec_scalar_tdiv_q_si(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c) - void _fmpz_vec_scalar_tdiv_q_ui(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong c) - void _fmpz_vec_scalar_tdiv_q_2exp(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong exp) - void _fmpz_vec_scalar_addmul_si(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c) - void _fmpz_vec_scalar_addmul_ui(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, ulong c) - void _fmpz_vec_scalar_addmul_fmpz(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, const fmpz_t c) - void _fmpz_vec_scalar_addmul_si_2exp(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c, ulong exp) - void _fmpz_vec_scalar_submul_fmpz(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, const fmpz_t x) - void _fmpz_vec_scalar_submul_si(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c) - void _fmpz_vec_scalar_submul_si_2exp(fmpz_struct * vec1, const fmpz_struct * vec2, slong len2, slong c, ulong e) - void _fmpz_vec_sum(fmpz_t res, const fmpz_struct * vec, slong len) - void _fmpz_vec_prod(fmpz_t res, const fmpz_struct * vec, slong len) - void _fmpz_vec_scalar_mod_fmpz(fmpz_struct * res, const fmpz_struct * vec, slong len, const fmpz_t p) - void _fmpz_vec_scalar_smod_fmpz(fmpz_struct * res, const fmpz_struct * vec, slong len, const fmpz_t p) - void _fmpz_vec_content(fmpz_t res, const fmpz_struct * vec, slong len) - void _fmpz_vec_content_chained(fmpz_t res, const fmpz_struct * vec, slong len, const fmpz_t input) - void _fmpz_vec_lcm(fmpz_t res, const fmpz_struct * vec, slong len) - void _fmpz_vec_dot_general_naive(fmpz_t res, const fmpz_t initial, int subtract, const fmpz_struct * a, const fmpz_struct * b, int reverse, slong len) - void _fmpz_vec_dot_general(fmpz_t res, const fmpz_t initial, int subtract, const fmpz_struct * a, const fmpz_struct * b, int reverse, slong len) - void _fmpz_vec_dot(fmpz_t res, const fmpz_struct * vec1, const fmpz_struct * vec2, slong len2) diff --git a/src/flint/flintlib/functions/fq.pxd b/src/flint/flintlib/functions/fq.pxd deleted file mode 100644 index bf3a4e83..00000000 --- a/src/flint/flintlib/functions/fq.pxd +++ /dev/null @@ -1,91 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_poly_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t, fmpz_mod_mat_t -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t -from flint.flintlib.types.fq cimport fq_ctx_t, fq_t - -# unknown type -# unknown type FILE - - -cdef extern from "flint/fq.h": - void fq_ctx_init(fq_ctx_t ctx, const fmpz_t p, slong d, const char * var) - int _fq_ctx_init_conway(fq_ctx_t ctx, const fmpz_t p, slong d, const char * var) - void fq_ctx_init_conway(fq_ctx_t ctx, const fmpz_t p, slong d, const char * var) - void fq_ctx_init_modulus(fq_ctx_t ctx, const fmpz_mod_poly_t modulus, const fmpz_mod_ctx_t ctxp, const char * var) - void fq_ctx_init_randtest(fq_ctx_t ctx, flint_rand_t state, int type) - void fq_ctx_init_randtest_reducible(fq_ctx_t ctx, flint_rand_t state, int type) - void fq_ctx_clear(fq_ctx_t ctx) - # const fmpz_mod_poly_struct* fq_ctx_modulus(const fq_ctx_t ctx) - slong fq_ctx_degree(const fq_ctx_t ctx) - const fmpz_struct * fq_ctx_prime(const fq_ctx_t ctx) - void fq_ctx_order(fmpz_t f, const fq_ctx_t ctx) - # int fq_ctx_fprint(FILE * file, const fq_ctx_t ctx) - void fq_ctx_print(const fq_ctx_t ctx) - void fq_init(fq_t rop, const fq_ctx_t ctx) - void fq_init2(fq_t rop, const fq_ctx_t ctx) - void fq_clear(fq_t rop, const fq_ctx_t ctx) - void _fq_sparse_reduce(fmpz_struct * R, slong lenR, const fq_ctx_t ctx) - void _fq_dense_reduce(fmpz_struct * R, slong lenR, const fq_ctx_t ctx) - void _fq_reduce(fmpz_struct * r, slong lenR, const fq_ctx_t ctx) - void fq_reduce(fq_t rop, const fq_ctx_t ctx) - void fq_add(fq_t rop, const fq_t op1, const fq_t op2, const fq_ctx_t ctx) - void fq_sub(fq_t rop, const fq_t op1, const fq_t op2, const fq_ctx_t ctx) - void fq_sub_one(fq_t rop, const fq_t op1, const fq_ctx_t ctx) - void fq_neg(fq_t rop, const fq_t op, const fq_ctx_t ctx) - void fq_mul(fq_t rop, const fq_t op1, const fq_t op2, const fq_ctx_t ctx) - void fq_mul_fmpz(fq_t rop, const fq_t op, const fmpz_t x, const fq_ctx_t ctx) - void fq_mul_si(fq_t rop, const fq_t op, slong x, const fq_ctx_t ctx) - void fq_mul_ui(fq_t rop, const fq_t op, ulong x, const fq_ctx_t ctx) - void fq_sqr(fq_t rop, const fq_t op, const fq_ctx_t ctx) - void fq_div(fq_t rop, const fq_t op1, const fq_t op2, const fq_ctx_t ctx) - void _fq_inv(fmpz_struct * rop, const fmpz_struct * op, slong len, const fq_ctx_t ctx) - void fq_inv(fq_t rop, const fq_t op, const fq_ctx_t ctx) - void fq_gcdinv(fq_t f, fq_t inv, const fq_t op, const fq_ctx_t ctx) - void _fq_pow(fmpz_struct * rop, const fmpz_struct * op, slong len, const fmpz_t e, const fq_ctx_t ctx) - void fq_pow(fq_t rop, const fq_t op, const fmpz_t e, const fq_ctx_t ctx) - void fq_pow_ui(fq_t rop, const fq_t op, const ulong e, const fq_ctx_t ctx) - int fq_sqrt(fq_t rop, const fq_t op1, const fq_ctx_t ctx) - void fq_pth_root(fq_t rop, const fq_t op1, const fq_ctx_t ctx) - int fq_is_square(const fq_t op, const fq_ctx_t ctx) - # int fq_fprint_pretty(FILE * file, const fq_t op, const fq_ctx_t ctx) - int fq_print_pretty(const fq_t op, const fq_ctx_t ctx) - # int fq_fprint(FILE * file, const fq_t op, const fq_ctx_t ctx) - void fq_print(const fq_t op, const fq_ctx_t ctx) - char * fq_get_str(const fq_t op, const fq_ctx_t ctx) - char * fq_get_str_pretty(const fq_t op, const fq_ctx_t ctx) - void fq_randtest(fq_t rop, flint_rand_t state, const fq_ctx_t ctx) - void fq_randtest_not_zero(fq_t rop, flint_rand_t state, const fq_ctx_t ctx) - void fq_randtest_dense(fq_t rop, flint_rand_t state, const fq_ctx_t ctx) - void fq_rand(fq_t rop, flint_rand_t state, const fq_ctx_t ctx) - void fq_rand_not_zero(fq_t rop, flint_rand_t state, const fq_ctx_t ctx) - void fq_set(fq_t rop, const fq_t op, const fq_ctx_t ctx) - void fq_set_si(fq_t rop, const slong x, const fq_ctx_t ctx) - void fq_set_ui(fq_t rop, const ulong x, const fq_ctx_t ctx) - void fq_set_fmpz(fq_t rop, const fmpz_t x, const fq_ctx_t ctx) - void fq_swap(fq_t op1, fq_t op2, const fq_ctx_t ctx) - void fq_zero(fq_t rop, const fq_ctx_t ctx) - void fq_one(fq_t rop, const fq_ctx_t ctx) - void fq_gen(fq_t rop, const fq_ctx_t ctx) - int fq_get_fmpz(fmpz_t rop, const fq_t op, const fq_ctx_t ctx) - void fq_get_fmpz_poly(fmpz_poly_t a, const fq_t b, const fq_ctx_t ctx) - void fq_get_fmpz_mod_poly(fmpz_mod_poly_t a, const fq_t b, const fq_ctx_t ctx) - void fq_set_fmpz_poly(fq_t a, const fmpz_poly_t b, const fq_ctx_t ctx) - void fq_set_fmpz_mod_poly(fq_t a, const fmpz_mod_poly_t b, const fq_ctx_t ctx) - void fq_get_fmpz_mod_mat(fmpz_mod_mat_t col, const fq_t a, const fq_ctx_t ctx) - void fq_set_fmpz_mod_mat(fq_t a, const fmpz_mod_mat_t col, const fq_ctx_t ctx) - int fq_is_zero(const fq_t op, const fq_ctx_t ctx) - int fq_is_one(const fq_t op, const fq_ctx_t ctx) - int fq_equal(const fq_t op1, const fq_t op2, const fq_ctx_t ctx) - int fq_is_invertible(const fq_t op, const fq_ctx_t ctx) - int fq_is_invertible_f(fq_t f, const fq_t op, const fq_ctx_t ctx) - void _fq_trace(fmpz_t rop, const fmpz_struct * op, slong len, const fq_ctx_t ctx) - void fq_trace(fmpz_t rop, const fq_t op, const fq_ctx_t ctx) - void _fq_norm(fmpz_t rop, const fmpz_struct * op, slong len, const fq_ctx_t ctx) - void fq_norm(fmpz_t rop, const fq_t op, const fq_ctx_t ctx) - void _fq_frobenius(fmpz_struct * rop, const fmpz_struct * op, slong len, slong e, const fq_ctx_t ctx) - void fq_frobenius(fq_t rop, const fq_t op, slong e, const fq_ctx_t ctx) - int fq_multiplicative_order(fmpz_struct * ord, const fq_t op, const fq_ctx_t ctx) - int fq_is_primitive(const fq_t op, const fq_ctx_t ctx) - void fq_bit_pack(fmpz_t f, const fq_t op, flint_bitcnt_t bit_size, const fq_ctx_t ctx) - void fq_bit_unpack(fq_t rop, const fmpz_t f, flint_bitcnt_t bit_size, const fq_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_default.pxd b/src/flint/flintlib/functions/fq_default.pxd deleted file mode 100644 index b69314d5..00000000 --- a/src/flint/flintlib/functions/fq_default.pxd +++ /dev/null @@ -1,79 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_poly_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t -from flint.flintlib.types.fq_default cimport fq_default_ctx_t, fq_default_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/fq_default.h": - void fq_default_ctx_init_type(fq_default_ctx_t ctx, const fmpz_t p, slong d, const char * var, int type) - void fq_default_ctx_init(fq_default_ctx_t ctx, const fmpz_t p, slong d, const char * var) - void fq_default_ctx_init_modulus_nmod_type(fq_default_ctx_t ctx, const nmod_poly_t modulus, const char * var, int type) - void fq_default_ctx_init_modulus_nmod(fq_default_ctx_t ctx, const nmod_poly_t modulus, const char * var) - void fq_default_ctx_init_modulus_type(fq_default_ctx_t ctx, const fmpz_mod_poly_t modulus, fmpz_mod_ctx_t mod_ctx, const char * var, int type) - void fq_default_ctx_init_modulus(fq_default_ctx_t ctx, const fmpz_mod_poly_t modulus, fmpz_mod_ctx_t mod_ctx, const char * var) - void fq_default_ctx_clear(fq_default_ctx_t ctx) - int fq_default_ctx_type(const fq_default_ctx_t ctx) - void * fq_default_ctx_inner(const fq_default_ctx_t ctx) - slong fq_default_ctx_degree(const fq_default_ctx_t ctx) - void fq_default_ctx_prime(fmpz_t prime, const fq_default_ctx_t ctx) - void fq_default_ctx_order(fmpz_t f, const fq_default_ctx_t ctx) - void fq_default_ctx_modulus(fmpz_mod_poly_t p, const fq_default_ctx_t ctx) - # int fq_default_ctx_fprint(FILE * file, const fq_default_ctx_t ctx) - void fq_default_ctx_print(const fq_default_ctx_t ctx) - void fq_default_ctx_init_randtest(fq_default_ctx_t ctx, flint_rand_t state) - void fq_default_get_coeff_fmpz(fmpz_t c, fq_default_t op, slong n, const fq_default_ctx_t ctx) - void fq_default_init(fq_default_t rop, const fq_default_ctx_t ctx) - void fq_default_init2(fq_default_t rop, const fq_default_ctx_t ctx) - void fq_default_clear(fq_default_t rop, const fq_default_ctx_t ctx) - int fq_default_is_invertible(const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_add(fq_default_t rop, const fq_default_t op1, const fq_default_t op2, const fq_default_ctx_t ctx) - void fq_default_sub(fq_default_t rop, const fq_default_t op1, const fq_default_t op2, const fq_default_ctx_t ctx) - void fq_default_sub_one(fq_default_t rop, const fq_default_t op1, const fq_default_ctx_t ctx) - void fq_default_neg(fq_default_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_mul(fq_default_t rop, const fq_default_t op1, const fq_default_t op2, const fq_default_ctx_t ctx) - void fq_default_mul_fmpz(fq_default_t rop, const fq_default_t op, const fmpz_t x, const fq_default_ctx_t ctx) - void fq_default_mul_si(fq_default_t rop, const fq_default_t op, slong x, const fq_default_ctx_t ctx) - void fq_default_mul_ui(fq_default_t rop, const fq_default_t op, ulong x, const fq_default_ctx_t ctx) - void fq_default_sqr(fq_default_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_div(fq_default_t rop, fq_default_t op1, fq_default_t op2, const fq_default_ctx_t ctx) - void fq_default_inv(fq_default_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_pow(fq_default_t rop, const fq_default_t op, const fmpz_t e, const fq_default_ctx_t ctx) - void fq_default_pow_ui(fq_default_t rop, const fq_default_t op, const ulong e, const fq_default_ctx_t ctx) - int fq_default_sqrt(fq_default_t rop, const fq_default_t op1, const fq_default_ctx_t ctx) - void fq_default_pth_root(fq_default_t rop, const fq_default_t op1, const fq_default_ctx_t ctx) - int fq_default_is_square(const fq_default_t op, const fq_default_ctx_t ctx) - # int fq_default_fprint_pretty(FILE * file, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_print_pretty(const fq_default_t op, const fq_default_ctx_t ctx) - # int fq_default_fprint(FILE * file, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_print(const fq_default_t op, const fq_default_ctx_t ctx) - char * fq_default_get_str(const fq_default_t op, const fq_default_ctx_t ctx) - char * fq_default_get_str_pretty(const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_randtest(fq_default_t rop, flint_rand_t state, const fq_default_ctx_t ctx) - void fq_default_randtest_not_zero(fq_default_t rop, flint_rand_t state, const fq_default_ctx_t ctx) - void fq_default_rand(fq_default_t rop, flint_rand_t state, const fq_default_ctx_t ctx) - void fq_default_rand_not_zero(fq_default_t rop, flint_rand_t state, const fq_default_ctx_t ctx) - void fq_default_set(fq_default_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_set_si(fq_default_t rop, const slong x, const fq_default_ctx_t ctx) - void fq_default_set_ui(fq_default_t rop, const ulong x, const fq_default_ctx_t ctx) - void fq_default_set_fmpz(fq_default_t rop, const fmpz_t x, const fq_default_ctx_t ctx) - void fq_default_swap(fq_default_t op1, fq_default_t op2, const fq_default_ctx_t ctx) - void fq_default_zero(fq_default_t rop, const fq_default_ctx_t ctx) - void fq_default_one(fq_default_t rop, const fq_default_ctx_t ctx) - void fq_default_gen(fq_default_t rop, const fq_default_ctx_t ctx) - int fq_default_get_fmpz(fmpz_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_get_nmod_poly(nmod_poly_t poly, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_set_nmod_poly(fq_default_t op, const nmod_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_get_fmpz_mod_poly(fmpz_mod_poly_t poly, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_set_fmpz_mod_poly(fq_default_t op, const fmpz_mod_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_get_fmpz_poly(fmpz_poly_t a, const fq_default_t b, const fq_default_ctx_t ctx) - void fq_default_set_fmpz_poly(fq_default_t a, const fmpz_poly_t b, const fq_default_ctx_t ctx) - int fq_default_is_zero(const fq_default_t op, const fq_default_ctx_t ctx) - int fq_default_is_one(const fq_default_t op, const fq_default_ctx_t ctx) - int fq_default_equal(const fq_default_t op1, const fq_default_t op2, const fq_default_ctx_t ctx) - void fq_default_trace(fmpz_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_norm(fmpz_t rop, const fq_default_t op, const fq_default_ctx_t ctx) - void fq_default_frobenius(fq_default_t rop, const fq_default_t op, slong e, const fq_default_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_default_mat.pxd b/src/flint/flintlib/functions/fq_default_mat.pxd deleted file mode 100644 index 563ab910..00000000 --- a/src/flint/flintlib/functions/fq_default_mat.pxd +++ /dev/null @@ -1,65 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong -from flint.flintlib.types.fmpz cimport fmpz_mat_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mat_t -from flint.flintlib.types.fq cimport fq_ctx_t, fq_mat_t, fq_struct -from flint.flintlib.types.fq_default cimport fq_default_ctx_t, fq_default_mat_t, fq_default_poly_t, fq_default_t -from flint.flintlib.types.nmod cimport nmod_mat_t - -# unknown type FILE - - -cdef extern from "flint/fq_default_mat.h": - void fq_default_mat_init(fq_default_mat_t mat, slong rows, slong cols, const fq_default_ctx_t ctx) - void fq_default_mat_init_set(fq_default_mat_t mat, const fq_default_mat_t src, const fq_default_ctx_t ctx) - void fq_default_mat_clear(fq_default_mat_t mat, const fq_default_ctx_t ctx) - void fq_default_mat_set(fq_default_mat_t mat, const fq_default_mat_t src, const fq_default_ctx_t ctx) - void fq_default_mat_entry(fq_default_t val, const fq_default_mat_t mat, slong i, slong j, const fq_default_ctx_t ctx) - void fq_default_mat_entry_set(fq_default_mat_t mat, slong i, slong j, const fq_default_t x, const fq_default_ctx_t ctx) - void fq_default_mat_entry_set_fmpz(fq_default_mat_t mat, slong i, slong j, const fmpz_t x, const fq_default_ctx_t ctx) - slong fq_default_mat_nrows(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - slong fq_default_mat_ncols(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - void fq_default_mat_swap(fq_default_mat_t mat1, fq_default_mat_t mat2, const fq_default_ctx_t ctx) - void fq_default_mat_zero(fq_default_mat_t mat, const fq_default_ctx_t ctx) - void fq_default_mat_one(fq_default_mat_t mat, const fq_default_ctx_t ctx) - void fq_default_mat_swap_rows(fq_default_mat_t mat, slong * perm, slong r, slong s, const fq_default_ctx_t ctx) - void fq_default_mat_swap_cols(fq_default_mat_t mat, slong * perm, slong r, slong s, const fq_default_ctx_t ctx) - void fq_default_mat_invert_rows(fq_default_mat_t mat, slong * perm, const fq_default_ctx_t ctx) - void fq_default_mat_invert_cols(fq_default_mat_t mat, slong * perm, const fq_default_ctx_t ctx) - void fq_default_mat_set_nmod_mat(fq_default_mat_t mat1, const nmod_mat_t mat2, const fq_default_ctx_t ctx) - void fq_default_mat_set_fmpz_mod_mat(fq_default_mat_t mat1, const fmpz_mod_mat_t mat2, const fq_default_ctx_t ctx) - void fq_default_mat_set_fmpz_mat(fq_default_mat_t mat1, const fmpz_mat_t mat2, const fq_default_ctx_t ctx) - void fq_default_mat_concat_vertical(fq_default_mat_t res, const fq_default_mat_t mat1, const fq_default_mat_t mat2, const fq_default_ctx_t ctx) - void fq_default_mat_concat_horizontal(fq_default_mat_t res, const fq_default_mat_t mat1, const fq_default_mat_t mat2, const fq_default_ctx_t ctx) - int fq_default_mat_print_pretty(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - # int fq_default_mat_fprint_pretty(FILE * file, const fq_default_mat_t mat, const fq_default_ctx_t ctx) - int fq_default_mat_print(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - # int fq_default_mat_fprint(FILE * file, const fq_default_mat_t mat, const fq_default_ctx_t ctx) - void fq_default_mat_window_init(fq_default_mat_t window, const fq_default_mat_t mat, slong r1, slong c1, slong r2, slong c2, const fq_default_ctx_t ctx) - void fq_default_mat_window_clear(fq_default_mat_t window, const fq_default_ctx_t ctx) - void fq_default_mat_randtest(fq_default_mat_t mat, flint_rand_t state, const fq_default_ctx_t ctx) - int fq_default_mat_randpermdiag(fq_mat_t mat, flint_rand_t state, fq_struct * diag, slong n, const fq_ctx_t ctx) - void fq_default_mat_randrank(fq_default_mat_t mat, flint_rand_t state, slong rank, const fq_default_ctx_t ctx) - void fq_default_mat_randops(fq_default_mat_t mat, flint_rand_t state, slong count, const fq_default_ctx_t ctx) - void fq_default_mat_randtril(fq_default_mat_t mat, flint_rand_t state, int unit, const fq_default_ctx_t ctx) - void fq_default_mat_randtriu(fq_default_mat_t mat, flint_rand_t state, int unit, const fq_default_ctx_t ctx) - int fq_default_mat_equal(const fq_default_mat_t mat1, const fq_default_mat_t mat2, const fq_default_ctx_t ctx) - int fq_default_mat_is_zero(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - int fq_default_mat_is_one(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - int fq_default_mat_is_empty(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - int fq_default_mat_is_square(const fq_default_mat_t mat, const fq_default_ctx_t ctx) - void fq_default_mat_transpose(fq_default_mat_t B, const fq_default_mat_t A, const fq_default_ctx_t ctx) - void fq_default_mat_add(fq_default_mat_t C, const fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - void fq_default_mat_sub(fq_default_mat_t C, const fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - void fq_default_mat_neg(fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - void fq_default_mat_mul(fq_default_mat_t C, const fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - void fq_default_mat_submul(fq_default_mat_t D, const fq_default_mat_t C, const fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - int fq_default_mat_inv(fq_default_mat_t B, fq_default_mat_t A, const fq_default_ctx_t ctx) - slong fq_default_mat_lu(slong * P, fq_default_mat_t A, int rank_check, const fq_default_ctx_t ctx) - slong fq_default_mat_rref(fq_default_mat_t B, const fq_default_mat_t A, const fq_default_ctx_t ctx) - void fq_default_mat_solve_tril(fq_default_mat_t X, const fq_default_mat_t L, const fq_default_mat_t B, int unit, const fq_default_ctx_t ctx) - void fq_default_mat_solve_triu(fq_default_mat_t X, const fq_default_mat_t U, const fq_default_mat_t B, int unit, const fq_default_ctx_t ctx) - int fq_default_mat_solve(fq_default_mat_t X, const fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - int fq_default_mat_can_solve(fq_default_mat_t X, const fq_default_mat_t A, const fq_default_mat_t B, const fq_default_ctx_t ctx) - void fq_default_mat_similarity(fq_default_mat_t M, slong r, fq_default_t d, const fq_default_ctx_t ctx) - void fq_default_mat_charpoly(fq_default_poly_t p, const fq_default_mat_t M, const fq_default_ctx_t ctx) - void fq_default_mat_minpoly(fq_default_poly_t p, const fq_default_mat_t M, const fq_default_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_default_poly.pxd b/src/flint/flintlib/functions/fq_default_poly.pxd deleted file mode 100644 index 36c5a4ad..00000000 --- a/src/flint/flintlib/functions/fq_default_poly.pxd +++ /dev/null @@ -1,90 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz cimport fmpz_poly_t -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t -from flint.flintlib.types.fq_default cimport fq_default_ctx_t, fq_default_poly_t, fq_default_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/fq_default_poly.h": - void fq_default_poly_init(fq_default_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_poly_init2(fq_default_poly_t poly, slong alloc, const fq_default_ctx_t ctx) - void fq_default_poly_realloc(fq_default_poly_t poly, slong alloc, const fq_default_ctx_t ctx) - void fq_default_poly_fit_length(fq_default_poly_t poly, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_clear(fq_default_poly_t poly, const fq_default_ctx_t ctx) - void _fq_default_poly_set_length(fq_default_poly_t poly, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_truncate(fq_default_poly_t poly, slong newlen, const fq_default_ctx_t ctx) - void fq_default_poly_set_trunc(fq_default_poly_t poly1, fq_default_poly_t poly2, slong newlen, const fq_default_ctx_t ctx) - void fq_default_poly_reverse(fq_default_poly_t output, const fq_default_poly_t input, slong m, const fq_default_ctx_t ctx) - slong fq_default_poly_degree(const fq_default_poly_t poly, const fq_default_ctx_t ctx) - slong fq_default_poly_length(const fq_default_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_poly_randtest(fq_default_poly_t f, flint_rand_t state, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_randtest_not_zero(fq_default_poly_t f, flint_rand_t state, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_randtest_monic(fq_default_poly_t f, flint_rand_t state, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_randtest_irreducible(fq_default_poly_t f, flint_rand_t state, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_set(fq_default_poly_t poly1, const fq_default_poly_t poly2, const fq_default_ctx_t ctx) - void fq_default_poly_set_fq_default(fq_default_poly_t poly, const fq_default_t c, const fq_default_ctx_t ctx) - void fq_default_poly_swap(fq_default_poly_t op1, fq_default_poly_t op2, const fq_default_ctx_t ctx) - void fq_default_poly_zero(fq_default_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_poly_one(fq_default_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_poly_gen(fq_default_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_poly_make_monic(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_set_nmod_poly(fq_default_poly_t rop, const nmod_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_set_fmpz_mod_poly(fq_default_poly_t rop, const fmpz_mod_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_set_fmpz_poly(fq_default_poly_t rop, const fmpz_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_get_coeff(fq_default_t x, const fq_default_poly_t poly, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_set_coeff(fq_default_poly_t poly, slong n, const fq_default_t x, const fq_default_ctx_t ctx) - void fq_default_poly_set_coeff_fmpz(fq_default_poly_t poly, slong n, const fmpz_t x, const fq_default_ctx_t ctx) - int fq_default_poly_equal(const fq_default_poly_t poly1, const fq_default_poly_t poly2, const fq_default_ctx_t ctx) - int fq_default_poly_equal_trunc(const fq_default_poly_t poly1, const fq_default_poly_t poly2, slong n, const fq_default_ctx_t ctx) - int fq_default_poly_is_zero(const fq_default_poly_t poly, const fq_default_ctx_t ctx) - int fq_default_poly_is_one(const fq_default_poly_t op, const fq_default_ctx_t ctx) - int fq_default_poly_is_gen(const fq_default_poly_t op, const fq_default_ctx_t ctx) - int fq_default_poly_is_unit(const fq_default_poly_t op, const fq_default_ctx_t ctx) - int fq_default_poly_equal_fq_default(const fq_default_poly_t poly, const fq_default_t c, const fq_default_ctx_t ctx) - void fq_default_poly_add(fq_default_poly_t res, const fq_default_poly_t poly1, const fq_default_poly_t poly2, const fq_default_ctx_t ctx) - void fq_default_poly_add_si(fq_default_poly_t res, const fq_default_poly_t poly1, slong c, const fq_default_ctx_t ctx) - void fq_default_poly_add_series(fq_default_poly_t res, const fq_default_poly_t poly1, const fq_default_poly_t poly2, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_sub(fq_default_poly_t res, const fq_default_poly_t poly1, const fq_default_poly_t poly2, const fq_default_ctx_t ctx) - void fq_default_poly_sub_series(fq_default_poly_t res, const fq_default_poly_t poly1, const fq_default_poly_t poly2, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_neg(fq_default_poly_t res, const fq_default_poly_t poly, const fq_default_ctx_t ctx) - void fq_default_poly_scalar_mul_fq_default(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_t x, const fq_default_ctx_t ctx) - void fq_default_poly_scalar_addmul_fq_default(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_t x, const fq_default_ctx_t ctx) - void fq_default_poly_scalar_submul_fq_default(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_t x, const fq_default_ctx_t ctx) - void fq_default_poly_scalar_div_fq_default(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_t x, const fq_default_ctx_t ctx) - void fq_default_poly_mul(fq_default_poly_t rop, const fq_default_poly_t op1, const fq_default_poly_t op2, const fq_default_ctx_t ctx) - void fq_default_poly_mullow(fq_default_poly_t rop, const fq_default_poly_t op1, const fq_default_poly_t op2, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_mulhigh(fq_default_poly_t res, const fq_default_poly_t poly1, const fq_default_poly_t poly2, slong start, const fq_default_ctx_t ctx) - void fq_default_poly_mulmod(fq_default_poly_t res, const fq_default_poly_t poly1, const fq_default_poly_t poly2, const fq_default_poly_t f, const fq_default_ctx_t ctx) - void fq_default_poly_sqr(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_pow(fq_default_poly_t rop, const fq_default_poly_t op, ulong e, const fq_default_ctx_t ctx) - void fq_default_poly_powmod_ui_binexp(fq_default_poly_t res, const fq_default_poly_t poly, ulong e, const fq_default_poly_t f, const fq_default_ctx_t ctx) - void fq_default_poly_powmod_fmpz_binexp(fq_default_poly_t res, const fq_default_poly_t poly, const fmpz_t e, const fq_default_poly_t f, const fq_default_ctx_t ctx) - void fq_default_poly_pow_trunc(fq_default_poly_t res, const fq_default_poly_t poly, ulong e, slong trunc, const fq_default_ctx_t ctx) - void fq_default_poly_shift_left(fq_default_poly_t rop, const fq_default_poly_t op, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_shift_right(fq_default_poly_t rop, const fq_default_poly_t op, slong n, const fq_default_ctx_t ctx) - slong fq_default_poly_hamming_weight(const fq_default_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_divrem(fq_default_poly_t Q, fq_default_poly_t R, const fq_default_poly_t A, const fq_default_poly_t B, const fq_default_ctx_t ctx) - void fq_default_poly_rem(fq_default_poly_t R, const fq_default_poly_t A, const fq_default_poly_t B, const fq_default_ctx_t ctx) - void fq_default_poly_inv_series(fq_default_poly_t Qinv, const fq_default_poly_t Q, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_div_series(fq_default_poly_t Q, const fq_default_poly_t A, const fq_default_poly_t B, slong n, const fq_default_ctx_t ctx) - void fq_default_poly_gcd(fq_default_poly_t rop, const fq_default_poly_t op1, const fq_default_poly_t op2, const fq_default_ctx_t ctx) - void fq_default_poly_xgcd(fq_default_poly_t G, fq_default_poly_t S, fq_default_poly_t T, const fq_default_poly_t A, const fq_default_poly_t B, const fq_default_ctx_t ctx) - int fq_default_poly_divides(fq_default_poly_t Q, const fq_default_poly_t A, const fq_default_poly_t B, const fq_default_ctx_t ctx) - void fq_default_poly_derivative(fq_default_poly_t rop, const fq_default_poly_t op, const fq_default_ctx_t ctx) - void fq_default_poly_invsqrt_series(fq_default_poly_t g, const fq_default_poly_t h, slong n, fq_default_ctx_t ctx) - void fq_default_poly_sqrt_series(fq_default_poly_t g, const fq_default_poly_t h, slong n, fq_default_ctx_t ctx) - int fq_default_poly_sqrt(fq_default_poly_t s, const fq_default_poly_t p, fq_default_ctx_t mod) - void fq_default_poly_evaluate_fq_default(fq_default_t rop, const fq_default_poly_t f, const fq_default_t a, const fq_default_ctx_t ctx) - void fq_default_poly_compose(fq_default_poly_t rop, const fq_default_poly_t op1, const fq_default_poly_t op2, const fq_default_ctx_t ctx) - void fq_default_poly_compose_mod(fq_default_poly_t res, const fq_default_poly_t f, const fq_default_poly_t g, const fq_default_poly_t h, const fq_default_ctx_t ctx) - # int fq_default_poly_fprint_pretty(FILE * file, const fq_default_poly_t poly, const char * x, const fq_default_ctx_t ctx) - int fq_default_poly_print_pretty(const fq_default_poly_t poly, const char * x, const fq_default_ctx_t ctx) - # int fq_default_poly_fprint(FILE * file, const fq_default_poly_t poly, const fq_default_ctx_t ctx) - int fq_default_poly_print(const fq_default_poly_t poly, const fq_default_ctx_t ctx) - char * fq_default_poly_get_str(const fq_default_poly_t poly, const fq_default_ctx_t ctx) - char * fq_default_poly_get_str_pretty(const fq_default_poly_t poly, const char * x, const fq_default_ctx_t ctx) - void fq_default_poly_inflate(fq_default_poly_t result, const fq_default_poly_t input, ulong inflation, const fq_default_ctx_t ctx) - void fq_default_poly_deflate(fq_default_poly_t result, const fq_default_poly_t input, ulong deflation, const fq_default_ctx_t ctx) - ulong fq_default_poly_deflation(const fq_default_poly_t input, const fq_default_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_default_poly_factor.pxd b/src/flint/flintlib/functions/fq_default_poly_factor.pxd deleted file mode 100644 index 7347f20a..00000000 --- a/src/flint/flintlib/functions/fq_default_poly_factor.pxd +++ /dev/null @@ -1,28 +0,0 @@ -from flint.flintlib.types.flint cimport slong, ulong -from flint.flintlib.types.fq_default cimport fq_default_ctx_t, fq_default_poly_factor_t, fq_default_poly_t, fq_default_t - - - -cdef extern from "flint/fq_default_poly_factor.h": - void fq_default_poly_factor_init(fq_default_poly_factor_t fac, const fq_default_ctx_t ctx) - void fq_default_poly_factor_clear(fq_default_poly_factor_t fac, const fq_default_ctx_t ctx) - void fq_default_poly_factor_realloc(fq_default_poly_factor_t fac, slong alloc, const fq_default_ctx_t ctx) - void fq_default_poly_factor_fit_length(fq_default_poly_factor_t fac, slong len, const fq_default_ctx_t ctx) - void fq_default_poly_factor_set(fq_default_poly_factor_t res, const fq_default_poly_factor_t fac, const fq_default_ctx_t ctx) - void fq_default_poly_factor_print_pretty(const fq_default_poly_factor_t fac, const char * var, const fq_default_ctx_t ctx) - void fq_default_poly_factor_print(const fq_default_poly_factor_t fac, const fq_default_ctx_t ctx) - void fq_default_poly_factor_insert(fq_default_poly_factor_t fac, const fq_default_poly_t poly, slong exp, const fq_default_ctx_t ctx) - void fq_default_poly_factor_concat(fq_default_poly_factor_t res, const fq_default_poly_factor_t fac, const fq_default_ctx_t ctx) - void fq_default_poly_factor_pow(fq_default_poly_factor_t fac, slong exp, const fq_default_ctx_t ctx) - ulong fq_default_poly_remove(fq_default_poly_t f, const fq_default_poly_t p, const fq_default_ctx_t ctx) - slong fq_default_poly_factor_length(fq_default_poly_factor_t fac, const fq_default_ctx_t ctx) - void fq_default_poly_factor_get_poly(fq_default_poly_t poly, const fq_default_poly_factor_t fac, slong i, const fq_default_ctx_t ctx) - slong fq_default_poly_factor_exp(fq_default_poly_factor_t fac, slong i, const fq_default_ctx_t ctx) - int fq_default_poly_is_irreducible(const fq_default_poly_t f, const fq_default_ctx_t ctx) - int fq_default_poly_is_squarefree(const fq_default_poly_t f, const fq_default_ctx_t ctx) - void fq_default_poly_factor_equal_deg(fq_default_poly_factor_t factors, const fq_default_poly_t pol, slong d, const fq_default_ctx_t ctx) - void fq_default_poly_factor_split_single(fq_default_poly_t linfactor, const fq_default_poly_t input, const fq_default_ctx_t ctx) - void fq_default_poly_factor_distinct_deg(fq_default_poly_factor_t res, const fq_default_poly_t poly, slong * const * degs, const fq_default_ctx_t ctx) - void fq_default_poly_factor_squarefree(fq_default_poly_factor_t res, const fq_default_poly_t f, const fq_default_ctx_t ctx) - void fq_default_poly_factor(fq_default_poly_factor_t res, fq_default_t lead, const fq_default_poly_t f, const fq_default_ctx_t ctx) - void fq_default_poly_roots(fq_default_poly_factor_t r, const fq_default_poly_t f, int with_multiplicity, const fq_default_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_mat.pxd b/src/flint/flintlib/functions/fq_mat.pxd deleted file mode 100644 index 85da9617..00000000 --- a/src/flint/flintlib/functions/fq_mat.pxd +++ /dev/null @@ -1,69 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mat_t -from flint.flintlib.types.fq cimport fq_ctx_t, fq_mat_t, fq_poly_t, fq_struct, fq_t -from flint.flintlib.types.nmod cimport nmod_mat_t - -# unknown type FILE - - -cdef extern from "flint/fq_mat.h": - void fq_mat_init(fq_mat_t mat, slong rows, slong cols, const fq_ctx_t ctx) - void fq_mat_init_set(fq_mat_t mat, const fq_mat_t src, const fq_ctx_t ctx) - void fq_mat_clear(fq_mat_t mat, const fq_ctx_t ctx) - void fq_mat_set(fq_mat_t mat, const fq_mat_t src, const fq_ctx_t ctx) - fq_struct * fq_mat_entry(const fq_mat_t mat, slong i, slong j) - void fq_mat_entry_set(fq_mat_t mat, slong i, slong j, const fq_t x, const fq_ctx_t ctx) - slong fq_mat_nrows(const fq_mat_t mat, const fq_ctx_t ctx) - slong fq_mat_ncols(const fq_mat_t mat, const fq_ctx_t ctx) - void fq_mat_swap(fq_mat_t mat1, fq_mat_t mat2, const fq_ctx_t ctx) - void fq_mat_swap_entrywise(fq_mat_t mat1, fq_mat_t mat2, const fq_ctx_t ctx) - void fq_mat_zero(fq_mat_t mat, const fq_ctx_t ctx) - void fq_mat_one(fq_mat_t mat, const fq_ctx_t ctx) - void fq_mat_swap_rows(fq_mat_t mat, slong * perm, slong r, slong s, const fq_ctx_t ctx) - void fq_mat_swap_cols(fq_mat_t mat, slong * perm, slong r, slong s, const fq_ctx_t ctx) - void fq_mat_invert_rows(fq_mat_t mat, slong * perm, const fq_ctx_t ctx) - void fq_mat_invert_cols(fq_mat_t mat, slong * perm, const fq_ctx_t ctx) - void fq_mat_set_nmod_mat(fq_mat_t mat1, const nmod_mat_t mat2, const fq_ctx_t ctx) - void fq_mat_set_fmpz_mod_mat(fq_mat_t mat1, const fmpz_mod_mat_t mat2, const fq_ctx_t ctx) - void fq_mat_concat_vertical(fq_mat_t res, const fq_mat_t mat1, const fq_mat_t mat2, const fq_ctx_t ctx) - void fq_mat_concat_horizontal(fq_mat_t res, const fq_mat_t mat1, const fq_mat_t mat2, const fq_ctx_t ctx) - int fq_mat_print_pretty(const fq_mat_t mat, const fq_ctx_t ctx) - # int fq_mat_fprint_pretty(FILE * file, const fq_mat_t mat, const fq_ctx_t ctx) - int fq_mat_print(const fq_mat_t mat, const fq_ctx_t ctx) - # int fq_mat_fprint(FILE * file, const fq_mat_t mat, const fq_ctx_t ctx) - void fq_mat_window_init(fq_mat_t window, const fq_mat_t mat, slong r1, slong c1, slong r2, slong c2, const fq_ctx_t ctx) - void fq_mat_window_clear(fq_mat_t window, const fq_ctx_t ctx) - void fq_mat_randtest(fq_mat_t mat, flint_rand_t state, const fq_ctx_t ctx) - int fq_mat_randpermdiag(fq_mat_t mat, flint_rand_t state, fq_struct * diag, slong n, const fq_ctx_t ctx) - void fq_mat_randrank(fq_mat_t mat, flint_rand_t state, slong rank, const fq_ctx_t ctx) - void fq_mat_randops(fq_mat_t mat, flint_rand_t state, slong count, const fq_ctx_t ctx) - void fq_mat_randtril(fq_mat_t mat, flint_rand_t state, int unit, const fq_ctx_t ctx) - void fq_mat_randtriu(fq_mat_t mat, flint_rand_t state, int unit, const fq_ctx_t ctx) - int fq_mat_equal(const fq_mat_t mat1, const fq_mat_t mat2, const fq_ctx_t ctx) - int fq_mat_is_zero(const fq_mat_t mat, const fq_ctx_t ctx) - int fq_mat_is_one(const fq_mat_t mat, const fq_ctx_t ctx) - int fq_mat_is_empty(const fq_mat_t mat, const fq_ctx_t ctx) - int fq_mat_is_square(const fq_mat_t mat, const fq_ctx_t ctx) - void fq_mat_transpose(fq_mat_t B, const fq_mat_t A, const fq_ctx_t ctx) - void fq_mat_add(fq_mat_t C, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_sub(fq_mat_t C, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_neg(fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_mul(fq_mat_t C, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_mul_classical(fq_mat_t C, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_mul_KS(fq_mat_t C, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_submul(fq_mat_t D, const fq_mat_t C, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_mul_vec(fq_struct * c, const fq_mat_t A, const fq_struct * b, slong blen, const fq_ctx_t ctx) - void fq_mat_mul_vec_ptr(fq_struct * const * c, const fq_mat_t A, const fq_struct * const * b, slong blen, const fq_ctx_t ctx) - void fq_mat_vec_mul(fq_struct * c, const fq_struct * a, slong alen, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_vec_mul_ptr(fq_struct * const * c, const fq_struct * const * a, slong alen, const fq_mat_t B, const fq_ctx_t ctx) - int fq_mat_inv(fq_mat_t B, fq_mat_t A, const fq_ctx_t ctx) - slong fq_mat_lu(slong * P, fq_mat_t A, int rank_check, const fq_ctx_t ctx) - slong fq_mat_rref(fq_mat_t B, const fq_mat_t A, const fq_ctx_t ctx) - slong fq_mat_reduce_row(fq_mat_t A, slong * P, slong * L, slong n, const fq_ctx_t ctx) - void fq_mat_solve_tril(fq_mat_t X, const fq_mat_t L, const fq_mat_t B, int unit, const fq_ctx_t ctx) - void fq_mat_solve_triu(fq_mat_t X, const fq_mat_t U, const fq_mat_t B, int unit, const fq_ctx_t ctx) - int fq_mat_solve(fq_mat_t X, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - int fq_mat_can_solve(fq_mat_t X, const fq_mat_t A, const fq_mat_t B, const fq_ctx_t ctx) - void fq_mat_similarity(fq_mat_t M, slong r, fq_t d, const fq_ctx_t ctx) - void fq_mat_charpoly(fq_poly_t p, const fq_mat_t M, const fq_ctx_t ctx) - void fq_mat_minpoly(fq_poly_t p, const fq_mat_t M, const fq_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_nmod.pxd b/src/flint/flintlib/functions/fq_nmod.pxd deleted file mode 100644 index e440eed1..00000000 --- a/src/flint/flintlib/functions/fq_nmod.pxd +++ /dev/null @@ -1,87 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.fq_nmod cimport fq_nmod_ctx_t, fq_nmod_t -from flint.flintlib.types.nmod cimport nmod_mat_t, nmod_poly_t - -# unknown type -# unknown type FILE - - -cdef extern from "flint/fq_nmod.h": - void fq_nmod_ctx_init_ui(fq_nmod_ctx_t ctx, ulong p, slong d, const char * var) - int _fq_nmod_ctx_init_conway_ui(fq_nmod_ctx_t ctx, ulong p, slong d, const char * var) - void fq_nmod_ctx_init_conway_ui(fq_nmod_ctx_t ctx, ulong p, slong d, const char * var) - void fq_nmod_ctx_init_modulus(fq_nmod_ctx_t ctx, const nmod_poly_t modulus, const char * var) - void fq_nmod_ctx_init_randtest(fq_nmod_ctx_t ctx, flint_rand_t state, int type) - void fq_nmod_ctx_init_randtest_reducible(fq_nmod_ctx_t ctx, flint_rand_t state, int type) - void fq_nmod_ctx_clear(fq_nmod_ctx_t ctx) - # const nmod_poly_struct* fq_nmod_ctx_modulus(const fq_nmod_ctx_t ctx) - slong fq_nmod_ctx_degree(const fq_nmod_ctx_t ctx) - ulong fq_nmod_ctx_prime(const fq_nmod_ctx_t ctx) - void fq_nmod_ctx_order(fmpz_t f, const fq_nmod_ctx_t ctx) - # int fq_nmod_ctx_fprint(FILE * file, const fq_nmod_ctx_t ctx) - void fq_nmod_ctx_print(const fq_nmod_ctx_t ctx) - void fq_nmod_init(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - void fq_nmod_init2(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - void fq_nmod_clear(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - void _fq_nmod_sparse_reduce(ulong * R, slong lenR, const fq_nmod_ctx_t ctx) - void _fq_nmod_dense_reduce(ulong * R, slong lenR, const fq_nmod_ctx_t ctx) - void _fq_nmod_reduce(ulong * r, slong lenR, const fq_nmod_ctx_t ctx) - void fq_nmod_reduce(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - void fq_nmod_add(fq_nmod_t rop, const fq_nmod_t op1, const fq_nmod_t op2, const fq_nmod_ctx_t ctx) - void fq_nmod_sub(fq_nmod_t rop, const fq_nmod_t op1, const fq_nmod_t op2, const fq_nmod_ctx_t ctx) - void fq_nmod_sub_one(fq_nmod_t rop, const fq_nmod_t op1, const fq_nmod_ctx_t ctx) - void fq_nmod_neg(fq_nmod_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_mul(fq_nmod_t rop, const fq_nmod_t op1, const fq_nmod_t op2, const fq_nmod_ctx_t ctx) - void fq_nmod_mul_fmpz(fq_nmod_t rop, const fq_nmod_t op, const fmpz_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_mul_si(fq_nmod_t rop, const fq_nmod_t op, slong x, const fq_nmod_ctx_t ctx) - void fq_nmod_mul_ui(fq_nmod_t rop, const fq_nmod_t op, ulong x, const fq_nmod_ctx_t ctx) - void fq_nmod_sqr(fq_nmod_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_inv(nn_ptr * rop, nn_srcptr * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_inv(fq_nmod_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_gcdinv(fq_nmod_t f, fq_nmod_t inv, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_pow(ulong * rop, const ulong * op, slong len, const fmpz_t e, const fq_nmod_ctx_t ctx) - void fq_nmod_pow(fq_nmod_t rop, const fq_nmod_t op, const fmpz_t e, const fq_nmod_ctx_t ctx) - void fq_nmod_pow_ui(fq_nmod_t rop, const fq_nmod_t op, const ulong e, const fq_nmod_ctx_t ctx) - int fq_nmod_sqrt(fq_nmod_t rop, const fq_nmod_t op1, const fq_nmod_ctx_t ctx) - void fq_nmod_pth_root(fq_nmod_t rop, const fq_nmod_t op1, const fq_nmod_ctx_t ctx) - int fq_nmod_is_square(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - # int fq_nmod_fprint_pretty(FILE * file, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_print_pretty(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - # int fq_nmod_fprint(FILE * file, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_print(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - char * fq_nmod_get_str(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - char * fq_nmod_get_str_pretty(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_randtest(fq_nmod_t rop, flint_rand_t state, const fq_nmod_ctx_t ctx) - void fq_nmod_randtest_not_zero(fq_nmod_t rop, flint_rand_t state, const fq_nmod_ctx_t ctx) - void fq_nmod_randtest_dense(fq_nmod_t rop, flint_rand_t state, const fq_nmod_ctx_t ctx) - void fq_nmod_rand(fq_nmod_t rop, flint_rand_t state, const fq_nmod_ctx_t ctx) - void fq_nmod_rand_not_zero(fq_nmod_t rop, flint_rand_t state, const fq_nmod_ctx_t ctx) - void fq_nmod_set(fq_nmod_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_set_si(fq_nmod_t rop, const slong x, const fq_nmod_ctx_t ctx) - void fq_nmod_set_ui(fq_nmod_t rop, const ulong x, const fq_nmod_ctx_t ctx) - void fq_nmod_set_fmpz(fq_nmod_t rop, const fmpz_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_swap(fq_nmod_t op1, fq_nmod_t op2, const fq_nmod_ctx_t ctx) - void fq_nmod_zero(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - void fq_nmod_one(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - void fq_nmod_gen(fq_nmod_t rop, const fq_nmod_ctx_t ctx) - int fq_nmod_get_fmpz(fmpz_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_get_nmod_poly(nmod_poly_t a, const fq_nmod_t b, const fq_nmod_ctx_t ctx) - void fq_nmod_set_nmod_poly(fq_nmod_t a, const nmod_poly_t b, const fq_nmod_ctx_t ctx) - void fq_nmod_get_nmod_mat(nmod_mat_t col, const fq_nmod_t a, const fq_nmod_ctx_t ctx) - void fq_nmod_set_nmod_mat(fq_nmod_t a, const nmod_mat_t col, const fq_nmod_ctx_t ctx) - int fq_nmod_is_zero(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_is_one(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_equal(const fq_nmod_t op1, const fq_nmod_t op2, const fq_nmod_ctx_t ctx) - int fq_nmod_is_invertible(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_is_invertible_f(fq_nmod_t f, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_cmp(const fq_nmod_t a, const fq_nmod_t b, const fq_nmod_ctx_t ctx) - void _fq_nmod_trace(fmpz_t rop, const ulong * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_trace(fmpz_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_norm(fmpz_t rop, const ulong * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_norm(fmpz_t rop, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_frobenius(ulong * rop, const ulong * op, slong len, slong e, const fq_nmod_ctx_t ctx) - void fq_nmod_frobenius(fq_nmod_t rop, const fq_nmod_t op, slong e, const fq_nmod_ctx_t ctx) - int fq_nmod_multiplicative_order(fmpz_struct * ord, const fq_nmod_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_is_primitive(const fq_nmod_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_bit_pack(fmpz_t f, const fq_nmod_t op, flint_bitcnt_t bit_size, const fq_nmod_ctx_t ctx) - void fq_nmod_bit_unpack(fq_nmod_t rop, const fmpz_t f, flint_bitcnt_t bit_size, const fq_nmod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_nmod_mat.pxd b/src/flint/flintlib/functions/fq_nmod_mat.pxd deleted file mode 100644 index 8f61e459..00000000 --- a/src/flint/flintlib/functions/fq_nmod_mat.pxd +++ /dev/null @@ -1,69 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mat_t -from flint.flintlib.types.fq_nmod cimport fq_nmod_ctx_t, fq_nmod_mat_t, fq_nmod_poly_t, fq_nmod_struct, fq_nmod_t -from flint.flintlib.types.nmod cimport nmod_mat_t - -# unknown type FILE - - -cdef extern from "flint/fq_nmod_mat.h": - void fq_nmod_mat_init(fq_nmod_mat_t mat, slong rows, slong cols, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_init_set(fq_nmod_mat_t mat, const fq_nmod_mat_t src, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_clear(fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_set(fq_nmod_mat_t mat, const fq_nmod_mat_t src, const fq_nmod_ctx_t ctx) - fq_nmod_struct * fq_nmod_mat_entry(const fq_nmod_mat_t mat, slong i, slong j) - void fq_nmod_mat_entry_set(fq_nmod_mat_t mat, slong i, slong j, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - slong fq_nmod_mat_nrows(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - slong fq_nmod_mat_ncols(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_swap(fq_nmod_mat_t mat1, fq_nmod_mat_t mat2, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_swap_entrywise(fq_nmod_mat_t mat1, fq_nmod_mat_t mat2, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_zero(fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_one(fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_swap_rows(fq_nmod_mat_t mat, slong * perm, slong r, slong s, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_swap_cols(fq_nmod_mat_t mat, slong * perm, slong r, slong s, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_invert_rows(fq_nmod_mat_t mat, slong * perm, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_invert_cols(fq_nmod_mat_t mat, slong * perm, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_set_nmod_mat(fq_nmod_mat_t mat1, const nmod_mat_t mat2, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_set_fmpz_mod_mat(fq_nmod_mat_t mat1, const fmpz_mod_mat_t mat2, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_concat_vertical(fq_nmod_mat_t res, const fq_nmod_mat_t mat1, const fq_nmod_mat_t mat2, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_concat_horizontal(fq_nmod_mat_t res, const fq_nmod_mat_t mat1, const fq_nmod_mat_t mat2, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_print_pretty(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - # int fq_nmod_mat_fprint_pretty(FILE * file, const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_print(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - # int fq_nmod_mat_fprint(FILE * file, const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_window_init(fq_nmod_mat_t window, const fq_nmod_mat_t mat, slong r1, slong c1, slong r2, slong c2, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_window_clear(fq_nmod_mat_t window, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_randtest(fq_nmod_mat_t mat, flint_rand_t state, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_randpermdiag(fq_nmod_mat_t mat, flint_rand_t state, fq_nmod_struct * diag, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_randrank(fq_nmod_mat_t mat, flint_rand_t state, slong rank, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_randops(fq_nmod_mat_t mat, flint_rand_t state, slong count, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_randtril(fq_nmod_mat_t mat, flint_rand_t state, int unit, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_randtriu(fq_nmod_mat_t mat, flint_rand_t state, int unit, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_equal(const fq_nmod_mat_t mat1, const fq_nmod_mat_t mat2, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_is_zero(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_is_one(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_is_empty(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_is_square(const fq_nmod_mat_t mat, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_transpose(fq_nmod_mat_t B, const fq_nmod_mat_t A, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_add(fq_nmod_mat_t C, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_sub(fq_nmod_mat_t C, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_neg(fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_mul(fq_nmod_mat_t C, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_mul_classical(fq_nmod_mat_t C, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_mul_KS(fq_nmod_mat_t C, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_submul(fq_nmod_mat_t D, const fq_nmod_mat_t C, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_mul_vec(fq_nmod_struct * c, const fq_nmod_mat_t A, const fq_nmod_struct * b, slong blen, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_mul_vec_ptr(fq_nmod_struct * const * c, const fq_nmod_mat_t A, const fq_nmod_struct * const * b, slong blen, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_vec_mul(fq_nmod_struct * c, const fq_nmod_struct * a, slong alen, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_vec_mul_ptr(fq_nmod_struct * const * c, const fq_nmod_struct * const * a, slong alen, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_inv(fq_nmod_mat_t B, fq_nmod_mat_t A, const fq_nmod_ctx_t ctx) - slong fq_nmod_mat_lu(slong * P, fq_nmod_mat_t A, int rank_check, const fq_nmod_ctx_t ctx) - slong fq_nmod_mat_rref(fq_nmod_mat_t B, const fq_nmod_mat_t A, const fq_nmod_ctx_t ctx) - slong fq_nmod_mat_reduce_row(fq_nmod_mat_t A, slong * P, slong * L, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_solve_tril(fq_nmod_mat_t X, const fq_nmod_mat_t L, const fq_nmod_mat_t B, int unit, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_solve_triu(fq_nmod_mat_t X, const fq_nmod_mat_t U, const fq_nmod_mat_t B, int unit, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_solve(fq_nmod_mat_t X, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - int fq_nmod_mat_can_solve(fq_nmod_mat_t X, const fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_similarity(fq_nmod_mat_t M, slong r, fq_nmod_t d, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_charpoly(fq_nmod_poly_t p, const fq_nmod_mat_t M, const fq_nmod_ctx_t ctx) - void fq_nmod_mat_minpoly(fq_nmod_poly_t p, const fq_nmod_mat_t M, const fq_nmod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_nmod_poly.pxd b/src/flint/flintlib/functions/fq_nmod_poly.pxd deleted file mode 100644 index 9c40d700..00000000 --- a/src/flint/flintlib/functions/fq_nmod_poly.pxd +++ /dev/null @@ -1,194 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t -from flint.flintlib.types.fq_nmod cimport fq_nmod_ctx_t, fq_nmod_mat_t, fq_nmod_poly_t, fq_nmod_struct, fq_nmod_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/fq_nmod_poly.h": - void fq_nmod_poly_init(fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_init2(fq_nmod_poly_t poly, slong alloc, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_realloc(fq_nmod_poly_t poly, slong alloc, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_fit_length(fq_nmod_poly_t poly, slong len, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_set_length(fq_nmod_poly_t poly, slong newlen, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_clear(fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_normalise(fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_normalise2(const fq_nmod_struct * poly, slong * length, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_truncate(fq_nmod_poly_t poly, slong newlen, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set_trunc(fq_nmod_poly_t poly1, fq_nmod_poly_t poly2, slong newlen, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_reverse(fq_nmod_struct * output, const fq_nmod_struct * input, slong len, slong m, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_reverse(fq_nmod_poly_t output, const fq_nmod_poly_t input, slong m, const fq_nmod_ctx_t ctx) - slong fq_nmod_poly_degree(const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - slong fq_nmod_poly_length(const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - fq_nmod_struct * fq_nmod_poly_lead(const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_randtest(fq_nmod_poly_t f, flint_rand_t state, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_randtest_not_zero(fq_nmod_poly_t f, flint_rand_t state, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_randtest_monic(fq_nmod_poly_t f, flint_rand_t state, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_randtest_irreducible(fq_nmod_poly_t f, flint_rand_t state, slong len, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_set(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set(fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set_fq_nmod(fq_nmod_poly_t poly, const fq_nmod_t c, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set_fmpz_mod_poly(fq_nmod_poly_t rop, const fmpz_mod_poly_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set_nmod_poly(fq_nmod_poly_t rop, const nmod_poly_t op, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_swap(fq_nmod_poly_t op1, fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_zero(fq_nmod_struct * rop, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_zero(fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_one(fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_gen(fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_make_monic(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_make_monic(fq_nmod_struct * rop, const fq_nmod_struct * op, slong length, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_get_coeff(fq_nmod_t x, const fq_nmod_poly_t poly, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set_coeff(fq_nmod_poly_t poly, slong n, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_set_coeff_fmpz(fq_nmod_poly_t poly, slong n, const fmpz_t x, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_equal(const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_equal_trunc(const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, slong n, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_zero(const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_one(const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_gen(const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_unit(const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_equal_fq_nmod(const fq_nmod_poly_t poly, const fq_nmod_t c, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_add(fq_nmod_struct * res, const fq_nmod_struct * poly1, slong len1, const fq_nmod_struct * poly2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_add(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_add_si(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, slong c, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_add_series(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_sub(fq_nmod_struct * res, const fq_nmod_struct * poly1, slong len1, const fq_nmod_struct * poly2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_sub(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_sub_series(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_neg(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_neg(fq_nmod_poly_t res, const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_scalar_mul_fq_nmod(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_scalar_mul_fq_nmod(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_scalar_addmul_fq_nmod(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_scalar_addmul_fq_nmod(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_scalar_submul_fq_nmod(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_scalar_submul_fq_nmod(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_scalar_div_fq(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_scalar_div_fq(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_t x, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mul_classical(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mul_classical(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mul_reorder(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mul_reorder(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mul_univariate(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mul_univariate(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mul_KS(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mul_KS(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mul(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mul(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mullow_classical(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mullow_classical(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mullow_univariate(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mullow_univariate(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mullow_KS(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mullow_KS(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mullow(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mullow(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mulhigh_classical(fq_nmod_struct * res, const fq_nmod_struct * poly1, slong len1, const fq_nmod_struct * poly2, slong len2, slong start, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mulhigh_classical(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, slong start, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mulhigh(fq_nmod_struct * res, const fq_nmod_struct * poly1, slong len1, const fq_nmod_struct * poly2, slong len2, slong start, fq_nmod_ctx_t ctx) - void fq_nmod_poly_mulhigh(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, slong start, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mulmod(fq_nmod_struct * res, const fq_nmod_struct * poly1, slong len1, const fq_nmod_struct * poly2, slong len2, const fq_nmod_struct * f, slong lenf, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mulmod(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_mulmod_preinv(fq_nmod_struct * res, const fq_nmod_struct * poly1, slong len1, const fq_nmod_struct * poly2, slong len2, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * finv, slong lenfinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_mulmod_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t poly1, const fq_nmod_poly_t poly2, const fq_nmod_poly_t f, const fq_nmod_poly_t finv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_sqr_classical(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_sqr_classical(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_sqr_KS(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_sqr_KS(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_sqr(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_sqr(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_pow(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, ulong e, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_pow(fq_nmod_poly_t rop, const fq_nmod_poly_t op, ulong e, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_powmod_ui_binexp(fq_nmod_struct * res, const fq_nmod_struct * poly, ulong e, const fq_nmod_struct * f, slong lenf, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_powmod_ui_binexp(fq_nmod_poly_t res, const fq_nmod_poly_t poly, ulong e, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_powmod_ui_binexp_preinv(fq_nmod_struct * res, const fq_nmod_struct * poly, ulong e, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * finv, slong lenfinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_powmod_ui_binexp_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t poly, ulong e, const fq_nmod_poly_t f, const fq_nmod_poly_t finv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_powmod_fmpz_binexp(fq_nmod_struct * res, const fq_nmod_struct * poly, const fmpz_t e, const fq_nmod_struct * f, slong lenf, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_powmod_fmpz_binexp(fq_nmod_poly_t res, const fq_nmod_poly_t poly, const fmpz_t e, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_powmod_fmpz_binexp_preinv(fq_nmod_struct * res, const fq_nmod_struct * poly, const fmpz_t e, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * finv, slong lenfinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_powmod_fmpz_binexp_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t poly, const fmpz_t e, const fq_nmod_poly_t f, const fq_nmod_poly_t finv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_powmod_fmpz_sliding_preinv(fq_nmod_struct * res, const fq_nmod_struct * poly, const fmpz_t e, ulong k, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * finv, slong lenfinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_powmod_fmpz_sliding_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t poly, const fmpz_t e, ulong k, const fq_nmod_poly_t f, const fq_nmod_poly_t finv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_powmod_x_fmpz_preinv(fq_nmod_struct * res, const fmpz_t e, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * finv, slong lenfinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_powmod_x_fmpz_preinv(fq_nmod_poly_t res, const fmpz_t e, const fq_nmod_poly_t f, const fq_nmod_poly_t finv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_pow_trunc_binexp(fq_nmod_struct * res, const fq_nmod_struct * poly, ulong e, slong trunc, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_pow_trunc_binexp(fq_nmod_poly_t res, const fq_nmod_poly_t poly, ulong e, slong trunc, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_pow_trunc(fq_nmod_struct * res, const fq_nmod_struct * poly, ulong e, slong trunc, const fq_nmod_ctx_t mod) - void fq_nmod_poly_pow_trunc(fq_nmod_poly_t res, const fq_nmod_poly_t poly, ulong e, slong trunc, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_shift_left(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_shift_left(fq_nmod_poly_t rop, const fq_nmod_poly_t op, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_shift_right(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_shift_right(fq_nmod_poly_t rop, const fq_nmod_poly_t op, slong n, const fq_nmod_ctx_t ctx) - slong _fq_nmod_poly_hamming_weight(const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - slong fq_nmod_poly_hamming_weight(const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_divrem(fq_nmod_struct * Q, fq_nmod_struct * R, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_t invB, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_divrem(fq_nmod_poly_t Q, fq_nmod_poly_t R, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_divrem_f(fq_nmod_t f, fq_nmod_poly_t Q, fq_nmod_poly_t R, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_rem(fq_nmod_struct * R, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_t invB, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_rem(fq_nmod_poly_t R, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_div(fq_nmod_struct * Q, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_t invB, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_div(fq_nmod_poly_t Q, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_div_newton_n_preinv(fq_nmod_struct * Q, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_struct * Binv, slong lenBinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_div_newton_n_preinv(fq_nmod_poly_t Q, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_poly_t Binv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_divrem_newton_n_preinv(fq_nmod_struct * Q, fq_nmod_struct * R, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_struct * Binv, slong lenBinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_divrem_newton_n_preinv(fq_nmod_poly_t Q, fq_nmod_poly_t R, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_poly_t Binv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_inv_series_newton(fq_nmod_struct * Qinv, const fq_nmod_struct * Q, slong n, const fq_nmod_t cinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_inv_series_newton(fq_nmod_poly_t Qinv, const fq_nmod_poly_t Q, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_inv_series(fq_nmod_struct * Qinv, const fq_nmod_struct * Q, slong n, const fq_nmod_t cinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_inv_series(fq_nmod_poly_t Qinv, const fq_nmod_poly_t Q, slong n, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_div_series(fq_nmod_struct * Q, const fq_nmod_struct * A, slong Alen, const fq_nmod_struct * B, slong Blen, slong n, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_div_series(fq_nmod_poly_t Q, const fq_nmod_poly_t A, const fq_nmod_poly_t B, slong n, fq_nmod_ctx_t ctx) - void fq_nmod_poly_gcd(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - slong _fq_nmod_poly_gcd(fq_nmod_struct * G, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_ctx_t ctx) - slong _fq_nmod_poly_gcd_euclidean_f(fq_nmod_t f, fq_nmod_struct * G, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_gcd_euclidean_f(fq_nmod_t f, fq_nmod_poly_t G, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - slong _fq_nmod_poly_xgcd(fq_nmod_struct * G, fq_nmod_struct * S, fq_nmod_struct * T, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_xgcd(fq_nmod_poly_t G, fq_nmod_poly_t S, fq_nmod_poly_t T, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - slong _fq_nmod_poly_xgcd_euclidean_f(fq_nmod_t f, fq_nmod_struct * G, fq_nmod_struct * S, fq_nmod_struct * T, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_xgcd_euclidean_f(fq_nmod_t f, fq_nmod_poly_t G, fq_nmod_poly_t S, fq_nmod_poly_t T, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - int _fq_nmod_poly_divides(fq_nmod_struct * Q, const fq_nmod_struct * A, slong lenA, const fq_nmod_struct * B, slong lenB, const fq_nmod_t invB, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_divides(fq_nmod_poly_t Q, const fq_nmod_poly_t A, const fq_nmod_poly_t B, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_derivative(fq_nmod_struct * rop, const fq_nmod_struct * op, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_derivative(fq_nmod_poly_t rop, const fq_nmod_poly_t op, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_invsqrt_series(fq_nmod_struct * g, const fq_nmod_struct * h, slong n, fq_nmod_ctx_t mod) - void fq_nmod_poly_invsqrt_series(fq_nmod_poly_t g, const fq_nmod_poly_t h, slong n, fq_nmod_ctx_t ctx) - void _fq_nmod_poly_sqrt_series(fq_nmod_struct * g, const fq_nmod_struct * h, slong n, fq_nmod_ctx_t ctx) - void fq_nmod_poly_sqrt_series(fq_nmod_poly_t g, const fq_nmod_poly_t h, slong n, fq_nmod_ctx_t ctx) - int _fq_nmod_poly_sqrt(fq_nmod_struct * s, const fq_nmod_struct * p, slong n, fq_nmod_ctx_t mod) - int fq_nmod_poly_sqrt(fq_nmod_poly_t s, const fq_nmod_poly_t p, fq_nmod_ctx_t mod) - void _fq_nmod_poly_evaluate_fq_nmod(fq_nmod_t rop, const fq_nmod_struct * op, slong len, const fq_nmod_t a, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_evaluate_fq_nmod(fq_nmod_t rop, const fq_nmod_poly_t f, const fq_nmod_t a, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose(fq_nmod_struct * rop, const fq_nmod_struct * op1, slong len1, const fq_nmod_struct * op2, slong len2, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose(fq_nmod_poly_t rop, const fq_nmod_poly_t op1, const fq_nmod_poly_t op2, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod_horner(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * g, const fq_nmod_struct * h, slong lenh, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod_horner(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t h, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod_horner_preinv(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * g, const fq_nmod_struct * h, slong lenh, const fq_nmod_struct * hinv, slong lenhiv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod_horner_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t h, const fq_nmod_poly_t hinv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod_brent_kung(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * g, const fq_nmod_struct * h, slong lenh, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod_brent_kung(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t h, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod_brent_kung_preinv(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * g, const fq_nmod_struct * h, slong lenh, const fq_nmod_struct * hinv, slong lenhiv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod_brent_kung_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t h, const fq_nmod_poly_t hinv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * g, const fq_nmod_struct * h, slong lenh, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t h, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod_preinv(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_struct * g, const fq_nmod_struct * h, slong lenh, const fq_nmod_struct * hinv, slong lenhiv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t h, const fq_nmod_poly_t hinv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_reduce_matrix_mod_poly (fq_nmod_mat_t A, const fq_nmod_mat_t B, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_precompute_matrix (fq_nmod_mat_t A, const fq_nmod_struct * f, const fq_nmod_struct * g, slong leng, const fq_nmod_struct * ginv, slong lenginv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_precompute_matrix (fq_nmod_mat_t A, const fq_nmod_poly_t f, const fq_nmod_poly_t g, const fq_nmod_poly_t ginv, const fq_nmod_ctx_t ctx) - void _fq_nmod_poly_compose_mod_brent_kung_precomp_preinv(fq_nmod_struct * res, const fq_nmod_struct * f, slong lenf, const fq_nmod_mat_t A, const fq_nmod_struct * h, slong lenh, const fq_nmod_struct * hinv, slong lenhinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_compose_mod_brent_kung_precomp_preinv(fq_nmod_poly_t res, const fq_nmod_poly_t f, const fq_nmod_mat_t A, const fq_nmod_poly_t h, const fq_nmod_poly_t hinv, const fq_nmod_ctx_t ctx) - # int _fq_nmod_poly_fprint_pretty(FILE * file, const fq_nmod_struct * poly, slong len, const char * x, const fq_nmod_ctx_t ctx) - # int fq_nmod_poly_fprint_pretty(FILE * file, const fq_nmod_poly_t poly, const char * x, const fq_nmod_ctx_t ctx) - int _fq_nmod_poly_print_pretty(const fq_nmod_struct * poly, slong len, const char * x, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_print_pretty(const fq_nmod_poly_t poly, const char * x, const fq_nmod_ctx_t ctx) - # int _fq_nmod_poly_fprint(FILE * file, const fq_nmod_struct * poly, slong len, const fq_nmod_ctx_t ctx) - # int fq_nmod_poly_fprint(FILE * file, const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - int _fq_nmod_poly_print(const fq_nmod_struct * poly, slong len, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_print(const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - char * _fq_nmod_poly_get_str(const fq_nmod_struct * poly, slong len, const fq_nmod_ctx_t ctx) - char * fq_nmod_poly_get_str(const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - char * _fq_nmod_poly_get_str_pretty(const fq_nmod_struct * poly, slong len, const char * x, const fq_nmod_ctx_t ctx) - char * fq_nmod_poly_get_str_pretty(const fq_nmod_poly_t poly, const char * x, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_inflate(fq_nmod_poly_t result, const fq_nmod_poly_t input, ulong inflation, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_deflate(fq_nmod_poly_t result, const fq_nmod_poly_t input, ulong deflation, const fq_nmod_ctx_t ctx) - ulong fq_nmod_poly_deflation(const fq_nmod_poly_t input, const fq_nmod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_nmod_poly_factor.pxd b/src/flint/flintlib/functions/fq_nmod_poly_factor.pxd deleted file mode 100644 index a6e7bf27..00000000 --- a/src/flint/flintlib/functions/fq_nmod_poly_factor.pxd +++ /dev/null @@ -1,36 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong, ulong -from flint.flintlib.types.fq_nmod cimport fq_nmod_ctx_t, fq_nmod_poly_factor_t, fq_nmod_poly_t, fq_nmod_struct, fq_nmod_t - - - -cdef extern from "flint/fq_nmod_poly_factor.h": - void fq_nmod_poly_factor_init(fq_nmod_poly_factor_t fac, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_clear(fq_nmod_poly_factor_t fac, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_realloc(fq_nmod_poly_factor_t fac, slong alloc, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_fit_length(fq_nmod_poly_factor_t fac, slong len, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_set(fq_nmod_poly_factor_t res, const fq_nmod_poly_factor_t fac, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_print_pretty(const fq_nmod_poly_factor_t fac, const char * var, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_print(const fq_nmod_poly_factor_t fac, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_insert(fq_nmod_poly_factor_t fac, const fq_nmod_poly_t poly, slong exp, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_concat(fq_nmod_poly_factor_t res, const fq_nmod_poly_factor_t fac, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_pow(fq_nmod_poly_factor_t fac, slong exp, const fq_nmod_ctx_t ctx) - ulong fq_nmod_poly_remove(fq_nmod_poly_t f, const fq_nmod_poly_t p, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_irreducible(const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_irreducible_ddf(const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_irreducible_ben_or(const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - int _fq_nmod_poly_is_squarefree(const fq_nmod_struct * f, slong len, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_is_squarefree(const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - int fq_nmod_poly_factor_equal_deg_prob(fq_nmod_poly_t factor, flint_rand_t state, const fq_nmod_poly_t pol, slong d, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_equal_deg(fq_nmod_poly_factor_t factors, const fq_nmod_poly_t pol, slong d, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_split_single(fq_nmod_poly_t linfactor, const fq_nmod_poly_t input, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_distinct_deg(fq_nmod_poly_factor_t res, const fq_nmod_poly_t poly, slong * const * degs, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_squarefree(fq_nmod_poly_factor_t res, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor(fq_nmod_poly_factor_t res, fq_nmod_t lead, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_cantor_zassenhaus(fq_nmod_poly_factor_t res, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_kaltofen_shoup(fq_nmod_poly_factor_t res, const fq_nmod_poly_t poly, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_berlekamp(fq_nmod_poly_factor_t factors, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_with_berlekamp(fq_nmod_poly_factor_t res, fq_nmod_t leading_coeff, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_with_cantor_zassenhaus(fq_nmod_poly_factor_t res, fq_nmod_t leading_coeff, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_factor_with_kaltofen_shoup(fq_nmod_poly_factor_t res, fq_nmod_t leading_coeff, const fq_nmod_poly_t f, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_iterated_frobenius_preinv(fq_nmod_poly_t * rop, slong n, const fq_nmod_poly_t v, const fq_nmod_poly_t vinv, const fq_nmod_ctx_t ctx) - void fq_nmod_poly_roots(fq_nmod_poly_factor_t r, const fq_nmod_poly_t f, int with_multiplicity, const fq_nmod_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_poly.pxd b/src/flint/flintlib/functions/fq_poly.pxd deleted file mode 100644 index 6eaa33e4..00000000 --- a/src/flint/flintlib/functions/fq_poly.pxd +++ /dev/null @@ -1,196 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t -from flint.flintlib.types.fq cimport fq_ctx_t, fq_mat_t, fq_poly_t, fq_struct, fq_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/fq_poly.h": - void fq_poly_init(fq_poly_t poly, const fq_ctx_t ctx) - void fq_poly_init2(fq_poly_t poly, slong alloc, const fq_ctx_t ctx) - void fq_poly_realloc(fq_poly_t poly, slong alloc, const fq_ctx_t ctx) - void fq_poly_fit_length(fq_poly_t poly, slong len, const fq_ctx_t ctx) - void _fq_poly_set_length(fq_poly_t poly, slong newlen, const fq_ctx_t ctx) - void fq_poly_clear(fq_poly_t poly, const fq_ctx_t ctx) - void _fq_poly_normalise(fq_poly_t poly, const fq_ctx_t ctx) - void _fq_poly_normalise2(const fq_struct * poly, slong * length, const fq_ctx_t ctx) - void fq_poly_truncate(fq_poly_t poly, slong newlen, const fq_ctx_t ctx) - void fq_poly_set_trunc(fq_poly_t poly1, fq_poly_t poly2, slong newlen, const fq_ctx_t ctx) - void _fq_poly_reverse(fq_struct * output, const fq_struct * input, slong len, slong m, const fq_ctx_t ctx) - void fq_poly_reverse(fq_poly_t output, const fq_poly_t input, slong m, const fq_ctx_t ctx) - slong fq_poly_degree(const fq_poly_t poly, const fq_ctx_t ctx) - slong fq_poly_length(const fq_poly_t poly, const fq_ctx_t ctx) - fq_struct * fq_poly_lead(const fq_poly_t poly, const fq_ctx_t ctx) - void fq_poly_randtest(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx) - void fq_poly_randtest_not_zero(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx) - void fq_poly_randtest_monic(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx) - void fq_poly_randtest_irreducible(fq_poly_t f, flint_rand_t state, slong len, const fq_ctx_t ctx) - void _fq_poly_set(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_set(fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx) - void fq_poly_set_fq(fq_poly_t poly, const fq_t c, const fq_ctx_t ctx) - void fq_poly_set_fmpz_mod_poly(fq_poly_t rop, const fmpz_mod_poly_t op, const fq_ctx_t ctx) - void fq_poly_set_nmod_poly(fq_poly_t rop, const nmod_poly_t op, const fq_ctx_t ctx) - void fq_poly_swap(fq_poly_t op1, fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_zero(fq_struct * rop, slong len, const fq_ctx_t ctx) - void fq_poly_zero(fq_poly_t poly, const fq_ctx_t ctx) - void fq_poly_one(fq_poly_t poly, const fq_ctx_t ctx) - void fq_poly_gen(fq_poly_t poly, const fq_ctx_t ctx) - void fq_poly_make_monic(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_make_monic(fq_struct * rop, const fq_struct * op, slong length, const fq_ctx_t ctx) - void fq_poly_get_coeff(fq_t x, const fq_poly_t poly, slong n, const fq_ctx_t ctx) - void fq_poly_set_coeff(fq_poly_t poly, slong n, const fq_t x, const fq_ctx_t ctx) - void fq_poly_set_coeff_fmpz(fq_poly_t poly, slong n, const fmpz_t x, const fq_ctx_t ctx) - int fq_poly_equal(const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx) - int fq_poly_equal_trunc(const fq_poly_t poly1, const fq_poly_t poly2, slong n, const fq_ctx_t ctx) - int fq_poly_is_zero(const fq_poly_t poly, const fq_ctx_t ctx) - int fq_poly_is_one(const fq_poly_t op, const fq_ctx_t ctx) - int fq_poly_is_gen(const fq_poly_t op, const fq_ctx_t ctx) - int fq_poly_is_unit(const fq_poly_t op, const fq_ctx_t ctx) - int fq_poly_equal_fq(const fq_poly_t poly, const fq_t c, const fq_ctx_t ctx) - void _fq_poly_add(fq_struct * res, const fq_struct * poly1, slong len1, const fq_struct * poly2, slong len2, const fq_ctx_t ctx) - void fq_poly_add(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx) - void fq_poly_add_si(fq_poly_t res, const fq_poly_t poly1, slong c, const fq_ctx_t ctx) - void fq_poly_add_series(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong n, const fq_ctx_t ctx) - void _fq_poly_sub(fq_struct * res, const fq_struct * poly1, slong len1, const fq_struct * poly2, slong len2, const fq_ctx_t ctx) - void fq_poly_sub(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_ctx_t ctx) - void fq_poly_sub_series(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong n, const fq_ctx_t ctx) - void _fq_poly_neg(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_neg(fq_poly_t res, const fq_poly_t poly, const fq_ctx_t ctx) - void _fq_poly_scalar_mul_fq(fq_struct * rop, const fq_struct * op, slong len, const fq_t x, const fq_ctx_t ctx) - void fq_poly_scalar_mul_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx) - void _fq_poly_scalar_addmul_fq(fq_struct * rop, const fq_struct * op, slong len, const fq_t x, const fq_ctx_t ctx) - void fq_poly_scalar_addmul_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx) - void _fq_poly_scalar_submul_fq(fq_struct * rop, const fq_struct * op, slong len, const fq_t x, const fq_ctx_t ctx) - void fq_poly_scalar_submul_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx) - void _fq_poly_scalar_div_fq(fq_struct * rop, const fq_struct * op, slong len, const fq_t x, const fq_ctx_t ctx) - void fq_poly_scalar_div_fq(fq_poly_t rop, const fq_poly_t op, const fq_t x, const fq_ctx_t ctx) - void _fq_poly_mul_classical(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, const fq_ctx_t ctx) - void fq_poly_mul_classical(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_mul_reorder(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, const fq_ctx_t ctx) - void fq_poly_mul_reorder(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_mul_univariate(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, const fq_ctx_t ctx) - void fq_poly_mul_univariate(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_mul_KS(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, const fq_ctx_t ctx) - void fq_poly_mul_KS(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_mul(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, const fq_ctx_t ctx) - void fq_poly_mul(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_mullow_classical(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, slong n, const fq_ctx_t ctx) - void fq_poly_mullow_classical(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx) - void _fq_poly_mullow_univariate(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, slong n, const fq_ctx_t ctx) - void fq_poly_mullow_univariate(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx) - void _fq_poly_mullow_KS(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, slong n, const fq_ctx_t ctx) - void fq_poly_mullow_KS(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx) - void _fq_poly_mullow(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, slong n, const fq_ctx_t ctx) - void fq_poly_mullow(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, slong n, const fq_ctx_t ctx) - void _fq_poly_mulhigh_classical(fq_struct * res, const fq_struct * poly1, slong len1, const fq_struct * poly2, slong len2, slong start, const fq_ctx_t ctx) - void fq_poly_mulhigh_classical(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong start, const fq_ctx_t ctx) - void _fq_poly_mulhigh(fq_struct * res, const fq_struct * poly1, slong len1, const fq_struct * poly2, slong len2, slong start, fq_ctx_t ctx) - void fq_poly_mulhigh(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, slong start, const fq_ctx_t ctx) - void _fq_poly_mulmod(fq_struct * res, const fq_struct * poly1, slong len1, const fq_struct * poly2, slong len2, const fq_struct * f, slong lenf, const fq_ctx_t ctx) - void fq_poly_mulmod(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_poly_t f, const fq_ctx_t ctx) - void _fq_poly_mulmod_preinv(fq_struct * res, const fq_struct * poly1, slong len1, const fq_struct * poly2, slong len2, const fq_struct * f, slong lenf, const fq_struct * finv, slong lenfinv, const fq_ctx_t ctx) - void fq_poly_mulmod_preinv(fq_poly_t res, const fq_poly_t poly1, const fq_poly_t poly2, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx) - void _fq_poly_sqr_classical(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_sqr_classical(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_sqr_reorder(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_sqr_reorder(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_sqr_KS(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_sqr_KS(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_sqr(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_sqr(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_pow(fq_struct * rop, const fq_struct * op, slong len, ulong e, const fq_ctx_t ctx) - void fq_poly_pow(fq_poly_t rop, const fq_poly_t op, ulong e, const fq_ctx_t ctx) - void _fq_poly_powmod_ui_binexp(fq_struct * res, const fq_struct * poly, ulong e, const fq_struct * f, slong lenf, const fq_ctx_t ctx) - void fq_poly_powmod_ui_binexp(fq_poly_t res, const fq_poly_t poly, ulong e, const fq_poly_t f, const fq_ctx_t ctx) - void _fq_poly_powmod_ui_binexp_preinv(fq_struct * res, const fq_struct * poly, ulong e, const fq_struct * f, slong lenf, const fq_struct * finv, slong lenfinv, const fq_ctx_t ctx) - void fq_poly_powmod_ui_binexp_preinv(fq_poly_t res, const fq_poly_t poly, ulong e, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx) - void _fq_poly_powmod_fmpz_binexp(fq_struct * res, const fq_struct * poly, const fmpz_t e, const fq_struct * f, slong lenf, const fq_ctx_t ctx) - void fq_poly_powmod_fmpz_binexp(fq_poly_t res, const fq_poly_t poly, const fmpz_t e, const fq_poly_t f, const fq_ctx_t ctx) - void _fq_poly_powmod_fmpz_binexp_preinv(fq_struct * res, const fq_struct * poly, const fmpz_t e, const fq_struct * f, slong lenf, const fq_struct * finv, slong lenfinv, const fq_ctx_t ctx) - void fq_poly_powmod_fmpz_binexp_preinv(fq_poly_t res, const fq_poly_t poly, const fmpz_t e, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx) - void _fq_poly_powmod_fmpz_sliding_preinv(fq_struct * res, const fq_struct * poly, const fmpz_t e, ulong k, const fq_struct * f, slong lenf, const fq_struct * finv, slong lenfinv, const fq_ctx_t ctx) - void fq_poly_powmod_fmpz_sliding_preinv(fq_poly_t res, const fq_poly_t poly, const fmpz_t e, ulong k, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx) - void _fq_poly_powmod_x_fmpz_preinv(fq_struct * res, const fmpz_t e, const fq_struct * f, slong lenf, const fq_struct * finv, slong lenfinv, const fq_ctx_t ctx) - void fq_poly_powmod_x_fmpz_preinv(fq_poly_t res, const fmpz_t e, const fq_poly_t f, const fq_poly_t finv, const fq_ctx_t ctx) - void _fq_poly_pow_trunc_binexp(fq_struct * res, const fq_struct * poly, ulong e, slong trunc, const fq_ctx_t ctx) - void fq_poly_pow_trunc_binexp(fq_poly_t res, const fq_poly_t poly, ulong e, slong trunc, const fq_ctx_t ctx) - void _fq_poly_pow_trunc(fq_struct * res, const fq_struct * poly, ulong e, slong trunc, const fq_ctx_t mod) - void fq_poly_pow_trunc(fq_poly_t res, const fq_poly_t poly, ulong e, slong trunc, const fq_ctx_t ctx) - void _fq_poly_shift_left(fq_struct * rop, const fq_struct * op, slong len, slong n, const fq_ctx_t ctx) - void fq_poly_shift_left(fq_poly_t rop, const fq_poly_t op, slong n, const fq_ctx_t ctx) - void _fq_poly_shift_right(fq_struct * rop, const fq_struct * op, slong len, slong n, const fq_ctx_t ctx) - void fq_poly_shift_right(fq_poly_t rop, const fq_poly_t op, slong n, const fq_ctx_t ctx) - slong _fq_poly_hamming_weight(const fq_struct * op, slong len, const fq_ctx_t ctx) - slong fq_poly_hamming_weight(const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_divrem(fq_struct * Q, fq_struct * R, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_t invB, const fq_ctx_t ctx) - void fq_poly_divrem(fq_poly_t Q, fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - void fq_poly_divrem_f(fq_t f, fq_poly_t Q, fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - void _fq_poly_rem(fq_struct * R, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_t invB, const fq_ctx_t ctx) - void fq_poly_rem(fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - void _fq_poly_div(fq_struct * Q, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_t invB, const fq_ctx_t ctx) - void fq_poly_div(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - void _fq_poly_div_newton_n_preinv(fq_struct * Q, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_struct * Binv, slong lenBinv, const fq_ctx_t ctx) - void fq_poly_div_newton_n_preinv(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B, const fq_poly_t Binv, const fq_ctx_t ctx) - void _fq_poly_divrem_newton_n_preinv(fq_struct * Q, fq_struct * R, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_struct * Binv, slong lenBinv, const fq_ctx_t ctx) - void fq_poly_divrem_newton_n_preinv(fq_poly_t Q, fq_poly_t R, const fq_poly_t A, const fq_poly_t B, const fq_poly_t Binv, const fq_ctx_t ctx) - void _fq_poly_inv_series_newton(fq_struct * Qinv, const fq_struct * Q, slong n, const fq_t cinv, const fq_ctx_t ctx) - void fq_poly_inv_series_newton(fq_poly_t Qinv, const fq_poly_t Q, slong n, const fq_ctx_t ctx) - void _fq_poly_inv_series(fq_struct * Qinv, const fq_struct * Q, slong n, const fq_t cinv, const fq_ctx_t ctx) - void fq_poly_inv_series(fq_poly_t Qinv, const fq_poly_t Q, slong n, const fq_ctx_t ctx) - void _fq_poly_div_series(fq_struct * Q, const fq_struct * A, slong Alen, const fq_struct * B, slong Blen, slong n, const fq_ctx_t ctx) - void fq_poly_div_series(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B, slong n, const fq_ctx_t ctx) - void fq_poly_gcd(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - slong _fq_poly_gcd(fq_struct * G, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_ctx_t ctx) - slong _fq_poly_gcd_euclidean_f(fq_t f, fq_struct * G, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_ctx_t ctx) - void fq_poly_gcd_euclidean_f(fq_t f, fq_poly_t G, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - slong _fq_poly_xgcd(fq_struct * G, fq_struct * S, fq_struct * T, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_ctx_t ctx) - void fq_poly_xgcd(fq_poly_t G, fq_poly_t S, fq_poly_t T, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - slong _fq_poly_xgcd_euclidean_f(fq_t f, fq_struct * G, fq_struct * S, fq_struct * T, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_ctx_t ctx) - void fq_poly_xgcd_euclidean_f(fq_t f, fq_poly_t G, fq_poly_t S, fq_poly_t T, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - int _fq_poly_divides(fq_struct * Q, const fq_struct * A, slong lenA, const fq_struct * B, slong lenB, const fq_t invB, const fq_ctx_t ctx) - int fq_poly_divides(fq_poly_t Q, const fq_poly_t A, const fq_poly_t B, const fq_ctx_t ctx) - void _fq_poly_derivative(fq_struct * rop, const fq_struct * op, slong len, const fq_ctx_t ctx) - void fq_poly_derivative(fq_poly_t rop, const fq_poly_t op, const fq_ctx_t ctx) - void _fq_poly_invsqrt_series(fq_struct * g, const fq_struct * h, slong n, fq_ctx_t mod) - void fq_poly_invsqrt_series(fq_poly_t g, const fq_poly_t h, slong n, fq_ctx_t ctx) - void _fq_poly_sqrt_series(fq_struct * g, const fq_struct * h, slong n, fq_ctx_t ctx) - void fq_poly_sqrt_series(fq_poly_t g, const fq_poly_t h, slong n, fq_ctx_t ctx) - int _fq_poly_sqrt(fq_struct * s, const fq_struct * p, slong n, fq_ctx_t mod) - int fq_poly_sqrt(fq_poly_t s, const fq_poly_t p, fq_ctx_t mod) - void _fq_poly_evaluate_fq(fq_t rop, const fq_struct * op, slong len, const fq_t a, const fq_ctx_t ctx) - void fq_poly_evaluate_fq(fq_t rop, const fq_poly_t f, const fq_t a, const fq_ctx_t ctx) - void _fq_poly_compose(fq_struct * rop, const fq_struct * op1, slong len1, const fq_struct * op2, slong len2, const fq_ctx_t ctx) - void fq_poly_compose(fq_poly_t rop, const fq_poly_t op1, const fq_poly_t op2, const fq_ctx_t ctx) - void _fq_poly_compose_mod_horner(fq_struct * res, const fq_struct * f, slong lenf, const fq_struct * g, const fq_struct * h, slong lenh, const fq_ctx_t ctx) - void fq_poly_compose_mod_horner(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_ctx_t ctx) - void _fq_poly_compose_mod_horner_preinv(fq_struct * res, const fq_struct * f, slong lenf, const fq_struct * g, const fq_struct * h, slong lenh, const fq_struct * hinv, slong lenhiv, const fq_ctx_t ctx) - void fq_poly_compose_mod_horner_preinv(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx) - void _fq_poly_compose_mod_brent_kung(fq_struct * res, const fq_struct * f, slong lenf, const fq_struct * g, const fq_struct * h, slong lenh, const fq_ctx_t ctx) - void fq_poly_compose_mod_brent_kung(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_ctx_t ctx) - void _fq_poly_compose_mod_brent_kung_preinv(fq_struct * res, const fq_struct * f, slong lenf, const fq_struct * g, const fq_struct * h, slong lenh, const fq_struct * hinv, slong lenhiv, const fq_ctx_t ctx) - void fq_poly_compose_mod_brent_kung_preinv(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx) - void _fq_poly_compose_mod(fq_struct * res, const fq_struct * f, slong lenf, const fq_struct * g, const fq_struct * h, slong lenh, const fq_ctx_t ctx) - void fq_poly_compose_mod(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_ctx_t ctx) - void _fq_poly_compose_mod_preinv(fq_struct * res, const fq_struct * f, slong lenf, const fq_struct * g, const fq_struct * h, slong lenh, const fq_struct * hinv, slong lenhiv, const fq_ctx_t ctx) - void fq_poly_compose_mod_preinv(fq_poly_t res, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx) - void _fq_poly_reduce_matrix_mod_poly (fq_mat_t A, const fq_mat_t B, const fq_poly_t f, const fq_ctx_t ctx) - void _fq_poly_precompute_matrix (fq_mat_t A, const fq_struct * f, const fq_struct * g, slong leng, const fq_struct * ginv, slong lenginv, const fq_ctx_t ctx) - void fq_poly_precompute_matrix (fq_mat_t A, const fq_poly_t f, const fq_poly_t g, const fq_poly_t ginv, const fq_ctx_t ctx) - void _fq_poly_compose_mod_brent_kung_precomp_preinv(fq_struct * res, const fq_struct * f, slong lenf, const fq_mat_t A, const fq_struct * h, slong lenh, const fq_struct * hinv, slong lenhinv, const fq_ctx_t ctx) - void fq_poly_compose_mod_brent_kung_precomp_preinv(fq_poly_t res, const fq_poly_t f, const fq_mat_t A, const fq_poly_t h, const fq_poly_t hinv, const fq_ctx_t ctx) - # int _fq_poly_fprint_pretty(FILE * file, const fq_struct * poly, slong len, const char * x, const fq_ctx_t ctx) - # int fq_poly_fprint_pretty(FILE * file, const fq_poly_t poly, const char * x, const fq_ctx_t ctx) - int _fq_poly_print_pretty(const fq_struct * poly, slong len, const char * x, const fq_ctx_t ctx) - int fq_poly_print_pretty(const fq_poly_t poly, const char * x, const fq_ctx_t ctx) - # int _fq_poly_fprint(FILE * file, const fq_struct * poly, slong len, const fq_ctx_t ctx) - # int fq_poly_fprint(FILE * file, const fq_poly_t poly, const fq_ctx_t ctx) - int _fq_poly_print(const fq_struct * poly, slong len, const fq_ctx_t ctx) - int fq_poly_print(const fq_poly_t poly, const fq_ctx_t ctx) - char * _fq_poly_get_str(const fq_struct * poly, slong len, const fq_ctx_t ctx) - char * fq_poly_get_str(const fq_poly_t poly, const fq_ctx_t ctx) - char * _fq_poly_get_str_pretty(const fq_struct * poly, slong len, const char * x, const fq_ctx_t ctx) - char * fq_poly_get_str_pretty(const fq_poly_t poly, const char * x, const fq_ctx_t ctx) - void fq_poly_inflate(fq_poly_t result, const fq_poly_t input, ulong inflation, const fq_ctx_t ctx) - void fq_poly_deflate(fq_poly_t result, const fq_poly_t input, ulong deflation, const fq_ctx_t ctx) - ulong fq_poly_deflation(const fq_poly_t input, const fq_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_poly_factor.pxd b/src/flint/flintlib/functions/fq_poly_factor.pxd deleted file mode 100644 index 2c5fb6f0..00000000 --- a/src/flint/flintlib/functions/fq_poly_factor.pxd +++ /dev/null @@ -1,36 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong, ulong -from flint.flintlib.types.fq cimport fq_ctx_t, fq_poly_factor_t, fq_poly_t, fq_struct, fq_t - - - -cdef extern from "flint/fq_poly_factor.h": - void fq_poly_factor_init(fq_poly_factor_t fac, const fq_ctx_t ctx) - void fq_poly_factor_clear(fq_poly_factor_t fac, const fq_ctx_t ctx) - void fq_poly_factor_realloc(fq_poly_factor_t fac, slong alloc, const fq_ctx_t ctx) - void fq_poly_factor_fit_length(fq_poly_factor_t fac, slong len, const fq_ctx_t ctx) - void fq_poly_factor_set(fq_poly_factor_t res, const fq_poly_factor_t fac, const fq_ctx_t ctx) - void fq_poly_factor_print_pretty(const fq_poly_factor_t fac, const char * var, const fq_ctx_t ctx) - void fq_poly_factor_print(const fq_poly_factor_t fac, const fq_ctx_t ctx) - void fq_poly_factor_insert(fq_poly_factor_t fac, const fq_poly_t poly, slong exp, const fq_ctx_t ctx) - void fq_poly_factor_concat(fq_poly_factor_t res, const fq_poly_factor_t fac, const fq_ctx_t ctx) - void fq_poly_factor_pow(fq_poly_factor_t fac, slong exp, const fq_ctx_t ctx) - ulong fq_poly_remove(fq_poly_t f, const fq_poly_t p, const fq_ctx_t ctx) - int fq_poly_is_irreducible(const fq_poly_t f, const fq_ctx_t ctx) - int fq_poly_is_irreducible_ddf(const fq_poly_t f, const fq_ctx_t ctx) - int fq_poly_is_irreducible_ben_or(const fq_poly_t f, const fq_ctx_t ctx) - int _fq_poly_is_squarefree(const fq_struct * f, slong len, const fq_ctx_t ctx) - int fq_poly_is_squarefree(const fq_poly_t f, const fq_ctx_t ctx) - int fq_poly_factor_equal_deg_prob(fq_poly_t factor, flint_rand_t state, const fq_poly_t pol, slong d, const fq_ctx_t ctx) - void fq_poly_factor_equal_deg(fq_poly_factor_t factors, const fq_poly_t pol, slong d, const fq_ctx_t ctx) - void fq_poly_factor_split_single(fq_poly_t linfactor, const fq_poly_t input, const fq_ctx_t ctx) - void fq_poly_factor_distinct_deg(fq_poly_factor_t res, const fq_poly_t poly, slong * const * degs, const fq_ctx_t ctx) - void fq_poly_factor_squarefree(fq_poly_factor_t res, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_factor(fq_poly_factor_t res, fq_t lead, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_factor_cantor_zassenhaus(fq_poly_factor_t res, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_factor_kaltofen_shoup(fq_poly_factor_t res, const fq_poly_t poly, const fq_ctx_t ctx) - void fq_poly_factor_berlekamp(fq_poly_factor_t factors, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_factor_with_berlekamp(fq_poly_factor_t res, fq_t leading_coeff, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_factor_with_cantor_zassenhaus(fq_poly_factor_t res, fq_t leading_coeff, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_factor_with_kaltofen_shoup(fq_poly_factor_t res, fq_t leading_coeff, const fq_poly_t f, const fq_ctx_t ctx) - void fq_poly_iterated_frobenius_preinv(fq_poly_t * rop, slong n, const fq_poly_t v, const fq_poly_t vinv, const fq_ctx_t ctx) - void fq_poly_roots(fq_poly_factor_t r, const fq_poly_t f, int with_multiplicity, const fq_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_zech.pxd b/src/flint/flintlib/functions/fq_zech.pxd deleted file mode 100644 index e97a702c..00000000 --- a/src/flint/flintlib/functions/fq_zech.pxd +++ /dev/null @@ -1,91 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.fq_nmod cimport fq_nmod_ctx_t, fq_nmod_t -from flint.flintlib.types.fq_zech cimport fq_zech_ctx_t, fq_zech_t -from flint.flintlib.types.nmod cimport nmod_mat_t, nmod_poly_struct, nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/fq_zech.h": - void fq_zech_ctx_init_ui(fq_zech_ctx_t ctx, ulong p, slong d, const char * var) - int _fq_zech_ctx_init_conway_ui(fq_zech_ctx_t ctx, ulong p, slong d, const char * var) - void fq_zech_ctx_init_conway_ui(fq_zech_ctx_t ctx, ulong p, slong d, const char * var) - void fq_zech_ctx_init_random_ui(fq_zech_ctx_t ctx, ulong p, slong d, const char * var) - void fq_zech_ctx_init_modulus(fq_zech_ctx_t ctx, const nmod_poly_t modulus, const char * var) - int fq_zech_ctx_init_modulus_check(fq_zech_ctx_t ctx, const nmod_poly_t modulus, const char * var) - void fq_zech_ctx_init_fq_nmod_ctx(fq_zech_ctx_t ctx, fq_nmod_ctx_t ctxn) - int fq_zech_ctx_init_fq_nmod_ctx_check(fq_zech_ctx_t ctx, fq_nmod_ctx_t ctxn) - void fq_zech_ctx_init_randtest(fq_zech_ctx_t ctx, flint_rand_t state, int type) - void fq_zech_ctx_init_randtest_reducible(fq_zech_ctx_t ctx, flint_rand_t state, int type) - void fq_zech_ctx_clear(fq_zech_ctx_t ctx) - const nmod_poly_struct * fq_zech_ctx_modulus(const fq_zech_ctx_t ctx) - slong fq_zech_ctx_degree(const fq_zech_ctx_t ctx) - ulong fq_zech_ctx_prime(const fq_zech_ctx_t ctx) - void fq_zech_ctx_order(fmpz_t f, const fq_zech_ctx_t ctx) - ulong fq_zech_ctx_order_ui(const fq_zech_ctx_t ctx) - # int fq_zech_ctx_fprint(FILE * file, const fq_zech_ctx_t ctx) - void fq_zech_ctx_print(const fq_zech_ctx_t ctx) - void fq_zech_init(fq_zech_t rop, const fq_zech_ctx_t ctx) - void fq_zech_init2(fq_zech_t rop, const fq_zech_ctx_t ctx) - void fq_zech_clear(fq_zech_t rop, const fq_zech_ctx_t ctx) - void _fq_zech_sparse_reduce(nn_ptr R, slong lenR, const fq_zech_ctx_t ctx) - void _fq_zech_dense_reduce(nn_ptr R, slong lenR, const fq_zech_ctx_t ctx) - void _fq_zech_reduce(nn_ptr r, slong lenR, const fq_zech_ctx_t ctx) - void fq_zech_reduce(fq_zech_t rop, const fq_zech_ctx_t ctx) - void fq_zech_add(fq_zech_t rop, const fq_zech_t op1, const fq_zech_t op2, const fq_zech_ctx_t ctx) - void fq_zech_sub(fq_zech_t rop, const fq_zech_t op1, const fq_zech_t op2, const fq_zech_ctx_t ctx) - void fq_zech_sub_one(fq_zech_t rop, const fq_zech_t op1, const fq_zech_ctx_t ctx) - void fq_zech_neg(fq_zech_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_mul(fq_zech_t rop, const fq_zech_t op1, const fq_zech_t op2, const fq_zech_ctx_t ctx) - void fq_zech_mul_fmpz(fq_zech_t rop, const fq_zech_t op, const fmpz_t x, const fq_zech_ctx_t ctx) - void fq_zech_mul_si(fq_zech_t rop, const fq_zech_t op, slong x, const fq_zech_ctx_t ctx) - void fq_zech_mul_ui(fq_zech_t rop, const fq_zech_t op, ulong x, const fq_zech_ctx_t ctx) - void fq_zech_sqr(fq_zech_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_div(fq_zech_t rop, const fq_zech_t op1, const fq_zech_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_inv(nn_ptr * rop, nn_srcptr * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_inv(fq_zech_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_gcdinv(fq_zech_t f, fq_zech_t inv, const fq_zech_t op, const fq_zech_ctx_t ctx) - void _fq_zech_pow(fmpz_struct * rop, const fmpz_struct * op, slong len, const fmpz_t e, const fmpz_struct * a, const slong * j, slong lena, const fmpz_t p) - void fq_zech_pow(fq_zech_t rop, const fq_zech_t op, const fmpz_t e, const fq_zech_ctx_t ctx) - void fq_zech_pow_ui(fq_zech_t rop, const fq_zech_t op, const ulong e, const fq_zech_ctx_t ctx) - int fq_zech_sqrt(fq_zech_t rop, const fq_zech_t op1, const fq_zech_ctx_t ctx) - void fq_zech_pth_root(fq_zech_t rop, const fq_zech_t op1, const fq_zech_ctx_t ctx) - int fq_zech_is_square(const fq_zech_t op, const fq_zech_ctx_t ctx) - # int fq_zech_fprint_pretty(FILE * file, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_print_pretty(const fq_zech_t op, const fq_zech_ctx_t ctx) - # int fq_zech_fprint(FILE * file, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_print(const fq_zech_t op, const fq_zech_ctx_t ctx) - char * fq_zech_get_str(const fq_zech_t op, const fq_zech_ctx_t ctx) - char * fq_zech_get_str_pretty(const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_randtest(fq_zech_t rop, flint_rand_t state, const fq_zech_ctx_t ctx) - void fq_zech_randtest_not_zero(fq_zech_t rop, flint_rand_t state, const fq_zech_ctx_t ctx) - void fq_zech_randtest_dense(fq_zech_t rop, flint_rand_t state, const fq_zech_ctx_t ctx) - void fq_zech_rand(fq_zech_t rop, flint_rand_t state, const fq_zech_ctx_t ctx) - void fq_zech_rand_not_zero(fq_zech_t rop, flint_rand_t state, const fq_zech_ctx_t ctx) - void fq_zech_set(fq_zech_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_set_si(fq_zech_t rop, const slong x, const fq_zech_ctx_t ctx) - void fq_zech_set_ui(fq_zech_t rop, const ulong x, const fq_zech_ctx_t ctx) - void fq_zech_set_fmpz(fq_zech_t rop, const fmpz_t x, const fq_zech_ctx_t ctx) - void fq_zech_swap(fq_zech_t op1, fq_zech_t op2, const fq_zech_ctx_t ctx) - void fq_zech_zero(fq_zech_t rop, const fq_zech_ctx_t ctx) - void fq_zech_one(fq_zech_t rop, const fq_zech_ctx_t ctx) - void fq_zech_gen(fq_zech_t rop, const fq_zech_ctx_t ctx) - int fq_zech_get_fmpz(fmpz_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_get_fq_nmod(fq_nmod_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_set_fq_nmod(fq_zech_t rop, const fq_nmod_t op, const fq_zech_ctx_t ctx) - void fq_zech_get_nmod_poly(nmod_poly_t a, const fq_zech_t b, const fq_zech_ctx_t ctx) - void fq_zech_set_nmod_poly(fq_zech_t a, const nmod_poly_t b, const fq_zech_ctx_t ctx) - void fq_zech_get_nmod_mat(nmod_mat_t col, const fq_zech_t a, const fq_zech_ctx_t ctx) - void fq_zech_set_nmod_mat(fq_zech_t a, const nmod_mat_t col, const fq_zech_ctx_t ctx) - int fq_zech_is_zero(const fq_zech_t op, const fq_zech_ctx_t ctx) - int fq_zech_is_one(const fq_zech_t op, const fq_zech_ctx_t ctx) - int fq_zech_equal(const fq_zech_t op1, const fq_zech_t op2, const fq_zech_ctx_t ctx) - int fq_zech_is_invertible(const fq_zech_t op, const fq_zech_ctx_t ctx) - int fq_zech_is_invertible_f(fq_zech_t f, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_trace(fmpz_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_norm(fmpz_t rop, const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_frobenius(fq_zech_t rop, const fq_zech_t op, slong e, const fq_zech_ctx_t ctx) - int fq_zech_multiplicative_order(fmpz_struct * ord, const fq_zech_t op, const fq_zech_ctx_t ctx) - int fq_zech_is_primitive(const fq_zech_t op, const fq_zech_ctx_t ctx) - void fq_zech_bit_pack(fmpz_t f, const fq_zech_t op, flint_bitcnt_t bit_size, const fq_zech_ctx_t ctx) - void fq_zech_bit_unpack(fq_zech_t rop, const fmpz_t f, flint_bitcnt_t bit_size, const fq_zech_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_zech_mat.pxd b/src/flint/flintlib/functions/fq_zech_mat.pxd deleted file mode 100644 index b72e6058..00000000 --- a/src/flint/flintlib/functions/fq_zech_mat.pxd +++ /dev/null @@ -1,63 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_mat_t -from flint.flintlib.types.fq_zech cimport fq_zech_ctx_t, fq_zech_mat_t, fq_zech_poly_t, fq_zech_struct, fq_zech_t -from flint.flintlib.types.nmod cimport nmod_mat_t - -# unknown type FILE - - -cdef extern from "flint/fq_zech_mat.h": - void fq_zech_mat_init(fq_zech_mat_t mat, slong rows, slong cols, const fq_zech_ctx_t ctx) - void fq_zech_mat_init_set(fq_zech_mat_t mat, const fq_zech_mat_t src, const fq_zech_ctx_t ctx) - void fq_zech_mat_clear(fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - void fq_zech_mat_set(fq_zech_mat_t mat, const fq_zech_mat_t src, const fq_zech_ctx_t ctx) - fq_zech_struct * fq_zech_mat_entry(const fq_zech_mat_t mat, slong i, slong j) - void fq_zech_mat_entry_set(fq_zech_mat_t mat, slong i, slong j, const fq_zech_t x, const fq_zech_ctx_t ctx) - slong fq_zech_mat_nrows(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - slong fq_zech_mat_ncols(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - void fq_zech_mat_swap(fq_zech_mat_t mat1, fq_zech_mat_t mat2, const fq_zech_ctx_t ctx) - void fq_zech_mat_swap_entrywise(fq_zech_mat_t mat1, fq_zech_mat_t mat2, const fq_zech_ctx_t ctx) - void fq_zech_mat_zero(fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - void fq_zech_mat_one(fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - void fq_zech_mat_set_nmod_mat(fq_zech_mat_t mat1, const nmod_mat_t mat2, const fq_zech_ctx_t ctx) - void fq_zech_mat_set_fmpz_mod_mat(fq_zech_mat_t mat1, const fmpz_mod_mat_t mat2, const fq_zech_ctx_t ctx) - void fq_zech_mat_concat_vertical(fq_zech_mat_t res, const fq_zech_mat_t mat1, const fq_zech_mat_t mat2, const fq_zech_ctx_t ctx) - void fq_zech_mat_concat_horizontal(fq_zech_mat_t res, const fq_zech_mat_t mat1, const fq_zech_mat_t mat2, const fq_zech_ctx_t ctx) - int fq_zech_mat_print_pretty(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - # int fq_zech_mat_fprint_pretty(FILE * file, const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - int fq_zech_mat_print(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - # int fq_zech_mat_fprint(FILE * file, const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - void fq_zech_mat_window_init(fq_zech_mat_t window, const fq_zech_mat_t mat, slong r1, slong c1, slong r2, slong c2, const fq_zech_ctx_t ctx) - void fq_zech_mat_window_clear(fq_zech_mat_t window, const fq_zech_ctx_t ctx) - void fq_zech_mat_randtest(fq_zech_mat_t mat, flint_rand_t state, const fq_zech_ctx_t ctx) - int fq_zech_mat_randpermdiag(fq_zech_mat_t mat, flint_rand_t state, fq_zech_struct * diag, slong n, const fq_zech_ctx_t ctx) - void fq_zech_mat_randrank(fq_zech_mat_t mat, flint_rand_t state, slong rank, const fq_zech_ctx_t ctx) - void fq_zech_mat_randops(fq_zech_mat_t mat, flint_rand_t state, slong count, const fq_zech_ctx_t ctx) - void fq_zech_mat_randtril(fq_zech_mat_t mat, flint_rand_t state, int unit, const fq_zech_ctx_t ctx) - void fq_zech_mat_randtriu(fq_zech_mat_t mat, flint_rand_t state, int unit, const fq_zech_ctx_t ctx) - int fq_zech_mat_equal(const fq_zech_mat_t mat1, const fq_zech_mat_t mat2, const fq_zech_ctx_t ctx) - int fq_zech_mat_is_zero(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - int fq_zech_mat_is_one(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - int fq_zech_mat_is_empty(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - int fq_zech_mat_is_square(const fq_zech_mat_t mat, const fq_zech_ctx_t ctx) - void fq_zech_mat_transpose(fq_zech_mat_t B, const fq_zech_mat_t A, const fq_zech_ctx_t ctx) - void fq_zech_mat_add(fq_zech_mat_t C, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_sub(fq_zech_mat_t C, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_neg(fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_mul(fq_zech_mat_t C, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_mul_classical(fq_zech_mat_t C, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_mul_KS(fq_zech_mat_t C, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_submul(fq_zech_mat_t D, const fq_zech_mat_t C, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_mul_vec(fq_zech_struct * c, const fq_zech_mat_t A, const fq_zech_struct * b, slong blen, const fq_zech_ctx_t ctx) - void fq_zech_mat_mul_vec_ptr(fq_zech_struct * const * c, const fq_zech_mat_t A, const fq_zech_struct * const * b, slong blen, const fq_zech_ctx_t ctx) - void fq_zech_mat_vec_mul(fq_zech_struct * c, const fq_zech_struct * a, slong alen, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_vec_mul_ptr(fq_zech_struct * const * c, const fq_zech_struct * const * a, slong alen, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - slong fq_zech_mat_lu(slong * P, fq_zech_mat_t A, int rank_check, const fq_zech_ctx_t ctx) - slong fq_zech_mat_rref(fq_zech_mat_t B, const fq_zech_mat_t A, const fq_zech_ctx_t ctx) - void fq_zech_mat_solve_tril(fq_zech_mat_t X, const fq_zech_mat_t L, const fq_zech_mat_t B, int unit, const fq_zech_ctx_t ctx) - void fq_zech_mat_solve_triu(fq_zech_mat_t X, const fq_zech_mat_t U, const fq_zech_mat_t B, int unit, const fq_zech_ctx_t ctx) - int fq_zech_mat_solve(fq_zech_mat_t X, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - int fq_zech_mat_can_solve(fq_zech_mat_t X, const fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_ctx_t ctx) - void fq_zech_mat_similarity(fq_zech_mat_t M, slong r, fq_zech_t d, const fq_zech_ctx_t ctx) - void fq_zech_mat_charpoly(fq_zech_poly_t p, const fq_zech_mat_t M, const fq_zech_ctx_t ctx) - void fq_zech_mat_minpoly(fq_zech_poly_t p, const fq_zech_mat_t M, const fq_zech_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_zech_poly.pxd b/src/flint/flintlib/functions/fq_zech_poly.pxd deleted file mode 100644 index f05259b3..00000000 --- a/src/flint/flintlib/functions/fq_zech_poly.pxd +++ /dev/null @@ -1,190 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpz_mod_poly cimport fmpz_mod_poly_t -from flint.flintlib.types.fq_zech cimport fq_zech_ctx_t, fq_zech_mat_t, fq_zech_poly_t, fq_zech_struct, fq_zech_t -from flint.flintlib.types.nmod cimport nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/fq_zech_poly.h": - void fq_zech_poly_init(fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void fq_zech_poly_init2(fq_zech_poly_t poly, slong alloc, const fq_zech_ctx_t ctx) - void fq_zech_poly_realloc(fq_zech_poly_t poly, slong alloc, const fq_zech_ctx_t ctx) - void fq_zech_poly_fit_length(fq_zech_poly_t poly, slong len, const fq_zech_ctx_t ctx) - void _fq_zech_poly_set_length(fq_zech_poly_t poly, slong newlen, const fq_zech_ctx_t ctx) - void fq_zech_poly_clear(fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void _fq_zech_poly_normalise(fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void _fq_zech_poly_normalise2(const fq_zech_struct * poly, slong * length, const fq_zech_ctx_t ctx) - void fq_zech_poly_truncate(fq_zech_poly_t poly, slong newlen, const fq_zech_ctx_t ctx) - void fq_zech_poly_set_trunc(fq_zech_poly_t poly1, fq_zech_poly_t poly2, slong newlen, const fq_zech_ctx_t ctx) - void _fq_zech_poly_reverse(fq_zech_struct * output, const fq_zech_struct * input, slong len, slong m, const fq_zech_ctx_t ctx) - void fq_zech_poly_reverse(fq_zech_poly_t output, const fq_zech_poly_t input, slong m, const fq_zech_ctx_t ctx) - slong fq_zech_poly_degree(const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - slong fq_zech_poly_length(const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - fq_zech_struct * fq_zech_poly_lead(const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void fq_zech_poly_randtest(fq_zech_poly_t f, flint_rand_t state, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_randtest_not_zero(fq_zech_poly_t f, flint_rand_t state, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_randtest_monic(fq_zech_poly_t f, flint_rand_t state, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_randtest_irreducible(fq_zech_poly_t f, flint_rand_t state, slong len, const fq_zech_ctx_t ctx) - void _fq_zech_poly_set(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_set(fq_zech_poly_t poly1, const fq_zech_poly_t poly2, const fq_zech_ctx_t ctx) - void fq_zech_poly_set_fq_zech(fq_zech_poly_t poly, const fq_zech_t c, const fq_zech_ctx_t ctx) - void fq_zech_poly_set_fmpz_mod_poly(fq_zech_poly_t rop, const fmpz_mod_poly_t op, const fq_zech_ctx_t ctx) - void fq_zech_poly_set_nmod_poly(fq_zech_poly_t rop, const nmod_poly_t op, const fq_zech_ctx_t ctx) - void fq_zech_poly_swap(fq_zech_poly_t op1, fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_poly_zero(fq_zech_struct * rop, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_zero(fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void fq_zech_poly_one(fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void fq_zech_poly_gen(fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void fq_zech_poly_make_monic(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - void _fq_zech_poly_make_monic(fq_zech_struct * rop, const fq_zech_struct * op, slong length, const fq_zech_ctx_t ctx) - void fq_zech_poly_get_coeff(fq_zech_t x, const fq_zech_poly_t poly, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_set_coeff(fq_zech_poly_t poly, slong n, const fq_zech_t x, const fq_zech_ctx_t ctx) - void fq_zech_poly_set_coeff_fmpz(fq_zech_poly_t poly, slong n, const fmpz_t x, const fq_zech_ctx_t ctx) - int fq_zech_poly_equal(const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, const fq_zech_ctx_t ctx) - int fq_zech_poly_equal_trunc(const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, slong n, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_zero(const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_one(const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_gen(const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_unit(const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - int fq_zech_poly_equal_fq_zech(const fq_zech_poly_t poly, const fq_zech_t c, const fq_zech_ctx_t ctx) - void _fq_zech_poly_add(fq_zech_struct * res, const fq_zech_struct * poly1, slong len1, const fq_zech_struct * poly2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_add(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, const fq_zech_ctx_t ctx) - void fq_zech_poly_add_si(fq_zech_poly_t res, const fq_zech_poly_t poly1, slong c, const fq_zech_ctx_t ctx) - void fq_zech_poly_add_series(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_sub(fq_zech_struct * res, const fq_zech_struct * poly1, slong len1, const fq_zech_struct * poly2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_sub(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, const fq_zech_ctx_t ctx) - void fq_zech_poly_sub_series(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_neg(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_neg(fq_zech_poly_t res, const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void _fq_zech_poly_scalar_mul_fq_zech(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_t x, const fq_zech_ctx_t ctx) - void fq_zech_poly_scalar_mul_fq_zech(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_t x, const fq_zech_ctx_t ctx) - void _fq_zech_poly_scalar_addmul_fq_zech(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_t x, const fq_zech_ctx_t ctx) - void fq_zech_poly_scalar_addmul_fq_zech(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_t x, const fq_zech_ctx_t ctx) - void _fq_zech_poly_scalar_submul_fq_zech(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_t x, const fq_zech_ctx_t ctx) - void fq_zech_poly_scalar_submul_fq_zech(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_t x, const fq_zech_ctx_t ctx) - void _fq_zech_poly_scalar_div_fq_zech(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_t x, const fq_zech_ctx_t ctx) - void fq_zech_poly_scalar_div_fq_zech(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_t x, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mul_classical(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_mul_classical(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mul_reorder(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_mul_reorder(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mul_KS(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_mul_KS(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mul(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_mul(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mullow_classical(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_mullow_classical(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mullow_KS(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_mullow_KS(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mullow(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_mullow(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mulhigh_classical(fq_zech_struct * res, const fq_zech_struct * poly1, slong len1, const fq_zech_struct * poly2, slong len2, slong start, const fq_zech_ctx_t ctx) - void fq_zech_poly_mulhigh_classical(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, slong start, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mulhigh(fq_zech_struct * res, const fq_zech_struct * poly1, slong len1, const fq_zech_struct * poly2, slong len2, slong start, fq_zech_ctx_t ctx) - void fq_zech_poly_mulhigh(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, slong start, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mulmod(fq_zech_struct * res, const fq_zech_struct * poly1, slong len1, const fq_zech_struct * poly2, slong len2, const fq_zech_struct * f, slong lenf, const fq_zech_ctx_t ctx) - void fq_zech_poly_mulmod(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void _fq_zech_poly_mulmod_preinv(fq_zech_struct * res, const fq_zech_struct * poly1, slong len1, const fq_zech_struct * poly2, slong len2, const fq_zech_struct * f, slong lenf, const fq_zech_struct * finv, slong lenfinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_mulmod_preinv(fq_zech_poly_t res, const fq_zech_poly_t poly1, const fq_zech_poly_t poly2, const fq_zech_poly_t f, const fq_zech_poly_t finv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_sqr_classical(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_sqr_classical(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - void _fq_zech_poly_sqr_KS(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_sqr_KS(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - void _fq_zech_poly_sqr(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_sqr(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - void _fq_zech_poly_pow(fq_zech_struct * rop, const fq_zech_struct * op, slong len, ulong e, const fq_zech_ctx_t ctx) - void fq_zech_poly_pow(fq_zech_poly_t rop, const fq_zech_poly_t op, ulong e, const fq_zech_ctx_t ctx) - void _fq_zech_poly_powmod_ui_binexp(fq_zech_struct * res, const fq_zech_struct * poly, ulong e, const fq_zech_struct * f, slong lenf, const fq_zech_ctx_t ctx) - void fq_zech_poly_powmod_ui_binexp(fq_zech_poly_t res, const fq_zech_poly_t poly, ulong e, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void _fq_zech_poly_powmod_ui_binexp_preinv(fq_zech_struct * res, const fq_zech_struct * poly, ulong e, const fq_zech_struct * f, slong lenf, const fq_zech_struct * finv, slong lenfinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_powmod_ui_binexp_preinv(fq_zech_poly_t res, const fq_zech_poly_t poly, ulong e, const fq_zech_poly_t f, const fq_zech_poly_t finv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_powmod_fmpz_binexp(fq_zech_struct * res, const fq_zech_struct * poly, const fmpz_t e, const fq_zech_struct * f, slong lenf, const fq_zech_ctx_t ctx) - void fq_zech_poly_powmod_fmpz_binexp(fq_zech_poly_t res, const fq_zech_poly_t poly, const fmpz_t e, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void _fq_zech_poly_powmod_fmpz_binexp_preinv(fq_zech_struct * res, const fq_zech_struct * poly, const fmpz_t e, const fq_zech_struct * f, slong lenf, const fq_zech_struct * finv, slong lenfinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_powmod_fmpz_binexp_preinv(fq_zech_poly_t res, const fq_zech_poly_t poly, const fmpz_t e, const fq_zech_poly_t f, const fq_zech_poly_t finv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_powmod_fmpz_sliding_preinv(fq_zech_struct * res, const fq_zech_struct * poly, const fmpz_t e, ulong k, const fq_zech_struct * f, slong lenf, const fq_zech_struct * finv, slong lenfinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_powmod_fmpz_sliding_preinv(fq_zech_poly_t res, const fq_zech_poly_t poly, const fmpz_t e, ulong k, const fq_zech_poly_t f, const fq_zech_poly_t finv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_powmod_x_fmpz_preinv(fq_zech_struct * res, const fmpz_t e, const fq_zech_struct * f, slong lenf, const fq_zech_struct * finv, slong lenfinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_powmod_x_fmpz_preinv(fq_zech_poly_t res, const fmpz_t e, const fq_zech_poly_t f, const fq_zech_poly_t finv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_pow_trunc_binexp(fq_zech_struct * res, const fq_zech_struct * poly, ulong e, slong trunc, const fq_zech_ctx_t ctx) - void fq_zech_poly_pow_trunc_binexp(fq_zech_poly_t res, const fq_zech_poly_t poly, ulong e, slong trunc, const fq_zech_ctx_t ctx) - void _fq_zech_poly_pow_trunc(fq_zech_struct * res, const fq_zech_struct * poly, ulong e, slong trunc, const fq_zech_ctx_t mod) - void fq_zech_poly_pow_trunc(fq_zech_poly_t res, const fq_zech_poly_t poly, ulong e, slong trunc, const fq_zech_ctx_t ctx) - void _fq_zech_poly_shift_left(fq_zech_struct * rop, const fq_zech_struct * op, slong len, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_shift_left(fq_zech_poly_t rop, const fq_zech_poly_t op, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_shift_right(fq_zech_struct * rop, const fq_zech_struct * op, slong len, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_shift_right(fq_zech_poly_t rop, const fq_zech_poly_t op, slong n, const fq_zech_ctx_t ctx) - slong _fq_zech_poly_hamming_weight(const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - slong fq_zech_poly_hamming_weight(const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - void _fq_zech_poly_divrem(fq_zech_struct * Q, fq_zech_struct * R, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_t invB, const fq_zech_ctx_t ctx) - void fq_zech_poly_divrem(fq_zech_poly_t Q, fq_zech_poly_t R, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - void fq_zech_poly_divrem_f(fq_zech_t f, fq_zech_poly_t Q, fq_zech_poly_t R, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - void _fq_zech_poly_rem(fq_zech_struct * R, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_t invB, const fq_zech_ctx_t ctx) - void fq_zech_poly_rem(fq_zech_poly_t R, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - void _fq_zech_poly_div(fq_zech_struct * Q, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_t invB, const fq_zech_ctx_t ctx) - void fq_zech_poly_div(fq_zech_poly_t Q, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - void _fq_zech_poly_div_newton_n_preinv(fq_zech_struct * Q, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_struct * Binv, slong lenBinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_div_newton_n_preinv(fq_zech_poly_t Q, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_poly_t Binv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_divrem_newton_n_preinv(fq_zech_struct * Q, fq_zech_struct * R, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_struct * Binv, slong lenBinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_divrem_newton_n_preinv(fq_zech_poly_t Q, fq_zech_poly_t R, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_poly_t Binv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_inv_series_newton(fq_zech_struct * Qinv, const fq_zech_struct * Q, slong n, const fq_zech_t cinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_inv_series_newton(fq_zech_poly_t Qinv, const fq_zech_poly_t Q, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_inv_series(fq_zech_struct * Qinv, const fq_zech_struct * Q, slong n, const fq_zech_t cinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_inv_series(fq_zech_poly_t Qinv, const fq_zech_poly_t Q, slong n, const fq_zech_ctx_t ctx) - void _fq_zech_poly_div_series(fq_zech_struct * Q, const fq_zech_struct * A, slong Alen, const fq_zech_struct * B, slong Blen, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_div_series(fq_zech_poly_t Q, const fq_zech_poly_t A, const fq_zech_poly_t B, slong n, const fq_zech_ctx_t ctx) - void fq_zech_poly_gcd(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - slong _fq_zech_poly_gcd(fq_zech_struct * G, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_ctx_t ctx) - slong _fq_zech_poly_gcd_euclidean_f(fq_zech_t f, fq_zech_struct * G, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_ctx_t ctx) - void fq_zech_poly_gcd_euclidean_f(fq_zech_t f, fq_zech_poly_t G, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - slong _fq_zech_poly_xgcd(fq_zech_struct * G, fq_zech_struct * S, fq_zech_struct * T, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_ctx_t ctx) - void fq_zech_poly_xgcd(fq_zech_poly_t G, fq_zech_poly_t S, fq_zech_poly_t T, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - slong _fq_zech_poly_xgcd_euclidean_f(fq_zech_t f, fq_zech_struct * G, fq_zech_struct * S, fq_zech_struct * T, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_ctx_t ctx) - void fq_zech_poly_xgcd_euclidean_f(fq_zech_t f, fq_zech_poly_t G, fq_zech_poly_t S, fq_zech_poly_t T, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - int _fq_zech_poly_divides(fq_zech_struct * Q, const fq_zech_struct * A, slong lenA, const fq_zech_struct * B, slong lenB, const fq_zech_t invB, const fq_zech_ctx_t ctx) - int fq_zech_poly_divides(fq_zech_poly_t Q, const fq_zech_poly_t A, const fq_zech_poly_t B, const fq_zech_ctx_t ctx) - void _fq_zech_poly_derivative(fq_zech_struct * rop, const fq_zech_struct * op, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_derivative(fq_zech_poly_t rop, const fq_zech_poly_t op, const fq_zech_ctx_t ctx) - void _fq_zech_poly_invsqrt_series(fq_zech_struct * g, const fq_zech_struct * h, slong n, fq_zech_ctx_t mod) - void fq_zech_poly_invsqrt_series(fq_zech_poly_t g, const fq_zech_poly_t h, slong n, fq_zech_ctx_t ctx) - void _fq_zech_poly_sqrt_series(fq_zech_struct * g, const fq_zech_struct * h, slong n, fq_zech_ctx_t ctx) - void fq_zech_poly_sqrt_series(fq_zech_poly_t g, const fq_zech_poly_t h, slong n, fq_zech_ctx_t ctx) - int _fq_zech_poly_sqrt(fq_zech_struct * s, const fq_zech_struct * p, slong n, fq_zech_ctx_t mod) - int fq_zech_poly_sqrt(fq_zech_poly_t s, const fq_zech_poly_t p, fq_zech_ctx_t mod) - void _fq_zech_poly_evaluate_fq_zech(fq_zech_t rop, const fq_zech_struct * op, slong len, const fq_zech_t a, const fq_zech_ctx_t ctx) - void fq_zech_poly_evaluate_fq_zech(fq_zech_t rop, const fq_zech_poly_t f, const fq_zech_t a, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose(fq_zech_struct * rop, const fq_zech_struct * op1, slong len1, const fq_zech_struct * op2, slong len2, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose(fq_zech_poly_t rop, const fq_zech_poly_t op1, const fq_zech_poly_t op2, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod_horner(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_struct * g, const fq_zech_struct * h, slong lenh, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod_horner(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t h, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod_horner_preinv(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_struct * g, const fq_zech_struct * h, slong lenh, const fq_zech_struct * hinv, slong lenhiv, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod_horner_preinv(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t h, const fq_zech_poly_t hinv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod_brent_kung(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_struct * g, const fq_zech_struct * h, slong lenh, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod_brent_kung(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t h, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod_brent_kung_preinv(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_struct * g, const fq_zech_struct * h, slong lenh, const fq_zech_struct * hinv, slong lenhiv, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod_brent_kung_preinv(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t h, const fq_zech_poly_t hinv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_struct * g, const fq_zech_struct * h, slong lenh, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t h, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod_preinv(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_struct * g, const fq_zech_struct * h, slong lenh, const fq_zech_struct * hinv, slong lenhiv, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod_preinv(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t h, const fq_zech_poly_t hinv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_reduce_matrix_mod_poly (fq_zech_mat_t A, const fq_zech_mat_t B, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void _fq_zech_poly_precompute_matrix (fq_zech_mat_t A, const fq_zech_struct * f, const fq_zech_struct * g, slong leng, const fq_zech_struct * ginv, slong lenginv, const fq_zech_ctx_t ctx) - void fq_zech_poly_precompute_matrix (fq_zech_mat_t A, const fq_zech_poly_t f, const fq_zech_poly_t g, const fq_zech_poly_t ginv, const fq_zech_ctx_t ctx) - void _fq_zech_poly_compose_mod_brent_kung_precomp_preinv(fq_zech_struct * res, const fq_zech_struct * f, slong lenf, const fq_zech_mat_t A, const fq_zech_struct * h, slong lenh, const fq_zech_struct * hinv, slong lenhinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_compose_mod_brent_kung_precomp_preinv(fq_zech_poly_t res, const fq_zech_poly_t f, const fq_zech_mat_t A, const fq_zech_poly_t h, const fq_zech_poly_t hinv, const fq_zech_ctx_t ctx) - # int _fq_zech_poly_fprint_pretty(FILE * file, const fq_zech_struct * poly, slong len, const char * x, const fq_zech_ctx_t ctx) - # int fq_zech_poly_fprint_pretty(FILE * file, const fq_zech_poly_t poly, const char * x, const fq_zech_ctx_t ctx) - int _fq_zech_poly_print_pretty(const fq_zech_struct * poly, slong len, const char * x, const fq_zech_ctx_t ctx) - int fq_zech_poly_print_pretty(const fq_zech_poly_t poly, const char * x, const fq_zech_ctx_t ctx) - # int _fq_zech_poly_fprint(FILE * file, const fq_zech_struct * poly, slong len, const fq_zech_ctx_t ctx) - # int fq_zech_poly_fprint(FILE * file, const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - int _fq_zech_poly_print(const fq_zech_struct * poly, slong len, const fq_zech_ctx_t ctx) - int fq_zech_poly_print(const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - char * _fq_zech_poly_get_str(const fq_zech_struct * poly, slong len, const fq_zech_ctx_t ctx) - char * fq_zech_poly_get_str(const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - char * _fq_zech_poly_get_str_pretty(const fq_zech_struct * poly, slong len, const char * x, const fq_zech_ctx_t ctx) - char * fq_zech_poly_get_str_pretty(const fq_zech_poly_t poly, const char * x, const fq_zech_ctx_t ctx) - void fq_zech_poly_inflate(fq_zech_poly_t result, const fq_zech_poly_t input, ulong inflation, const fq_zech_ctx_t ctx) - void fq_zech_poly_deflate(fq_zech_poly_t result, const fq_zech_poly_t input, ulong deflation, const fq_zech_ctx_t ctx) - ulong fq_zech_poly_deflation(const fq_zech_poly_t input, const fq_zech_ctx_t ctx) diff --git a/src/flint/flintlib/functions/fq_zech_poly_factor.pxd b/src/flint/flintlib/functions/fq_zech_poly_factor.pxd deleted file mode 100644 index cec3bcb2..00000000 --- a/src/flint/flintlib/functions/fq_zech_poly_factor.pxd +++ /dev/null @@ -1,36 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, slong, ulong -from flint.flintlib.types.fq_zech cimport fq_zech_ctx_t, fq_zech_poly_factor_t, fq_zech_poly_t, fq_zech_struct, fq_zech_t - - - -cdef extern from "flint/fq_zech_poly_factor.h": - void fq_zech_poly_factor_init(fq_zech_poly_factor_t fac, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_clear(fq_zech_poly_factor_t fac, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_realloc(fq_zech_poly_factor_t fac, slong alloc, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_fit_length(fq_zech_poly_factor_t fac, slong len, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_set(fq_zech_poly_factor_t res, const fq_zech_poly_factor_t fac, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_print_pretty(const fq_zech_poly_factor_t fac, const char * var, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_print(const fq_zech_poly_factor_t fac, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_insert(fq_zech_poly_factor_t fac, const fq_zech_poly_t poly, slong exp, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_concat(fq_zech_poly_factor_t res, const fq_zech_poly_factor_t fac, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_pow(fq_zech_poly_factor_t fac, slong exp, const fq_zech_ctx_t ctx) - ulong fq_zech_poly_remove(fq_zech_poly_t f, const fq_zech_poly_t p, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_irreducible(const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_irreducible_ddf(const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_irreducible_ben_or(const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - int _fq_zech_poly_is_squarefree(const fq_zech_struct * f, slong len, const fq_zech_ctx_t ctx) - int fq_zech_poly_is_squarefree(const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - int fq_zech_poly_factor_equal_deg_prob(fq_zech_poly_t factor, flint_rand_t state, const fq_zech_poly_t pol, slong d, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_equal_deg(fq_zech_poly_factor_t factors, const fq_zech_poly_t pol, slong d, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_split_single(fq_zech_poly_t linfactor, const fq_zech_poly_t input, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_distinct_deg(fq_zech_poly_factor_t res, const fq_zech_poly_t poly, slong * const * degs, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_squarefree(fq_zech_poly_factor_t res, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor(fq_zech_poly_factor_t res, fq_zech_t lead, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_cantor_zassenhaus(fq_zech_poly_factor_t res, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_kaltofen_shoup(fq_zech_poly_factor_t res, const fq_zech_poly_t poly, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_berlekamp(fq_zech_poly_factor_t factors, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_with_berlekamp(fq_zech_poly_factor_t res, fq_zech_t leading_coeff, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_with_cantor_zassenhaus(fq_zech_poly_factor_t res, fq_zech_t leading_coeff, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_factor_with_kaltofen_shoup(fq_zech_poly_factor_t res, fq_zech_t leading_coeff, const fq_zech_poly_t f, const fq_zech_ctx_t ctx) - void fq_zech_poly_iterated_frobenius_preinv(fq_zech_poly_t * rop, slong n, const fq_zech_poly_t v, const fq_zech_poly_t vinv, const fq_zech_ctx_t ctx) - void fq_zech_poly_roots(fq_zech_poly_factor_t r, const fq_zech_poly_t f, int with_multiplicity, const fq_zech_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr.pxd b/src/flint/flintlib/functions/gr.pxd deleted file mode 100644 index ef7475ec..00000000 --- a/src/flint/flintlib/functions/gr.pxd +++ /dev/null @@ -1,195 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_ptr, gr_srcptr, gr_stream_t, gr_vec_t, truth_t - -# unknown type fexpr_t -# unknown type fexpr_vec_t - -# .. macro:: GR_SUCCESS -# .. macro:: GR_DOMAIN -# .. macro:: GR_UNABLE -# .. macro:: GR_TEST_FAIL -# .. macro:: GR_MUST_SUCCEED(expr) -# .. macro:: GR_TMP_INIT_VEC(vec, len, ctx) -# .. macro:: GR_TMP_INIT(x1, ctx) -# .. macro:: GR_TMP_CLEAR(x1, ctx) - -cdef extern from "flint/gr.h": - truth_t truth_and(truth_t x, truth_t y) - truth_t truth_or(truth_t x, truth_t y) - truth_t truth_not(truth_t x) - void truth_println(truth_t x) - truth_t gr_in_domain(int status) - int gr_check(truth_t t) - slong gr_ctx_sizeof_elem(gr_ctx_t ctx) - void gr_ctx_clear(gr_ctx_t ctx) - int gr_ctx_write(gr_stream_t out, gr_ctx_t ctx) - int gr_ctx_print(gr_ctx_t ctx) - int gr_ctx_println(gr_ctx_t ctx) - int gr_ctx_get_str(char ** s, gr_ctx_t ctx) - int gr_ctx_set_gen_name(gr_ctx_t ctx, const char * s) - int gr_ctx_set_gen_names(gr_ctx_t ctx, const char ** s) - void gr_init(gr_ptr res, gr_ctx_t ctx) - void gr_clear(gr_ptr res, gr_ctx_t ctx) - void gr_swap(gr_ptr x, gr_ptr y, gr_ctx_t ctx) - void gr_set_shallow(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - gr_ptr gr_heap_init(gr_ctx_t ctx) - void gr_heap_clear(gr_ptr x, gr_ctx_t ctx) - gr_ptr gr_heap_init_vec(slong len, gr_ctx_t ctx) - void gr_heap_clear_vec(gr_ptr x, slong len, gr_ctx_t ctx) - int gr_randtest(gr_ptr res, flint_rand_t state, gr_ctx_t ctx) - int gr_randtest_invertible(gr_ptr res, flint_rand_t state, gr_ctx_t ctx) - int gr_randtest_not_zero(gr_ptr res, flint_rand_t state, gr_ctx_t ctx) - int gr_randtest_small(gr_ptr res, flint_rand_t state, gr_ctx_t ctx) - int gr_write(gr_stream_t out, gr_srcptr x, gr_ctx_t ctx) - int gr_print(gr_srcptr x, gr_ctx_t ctx) - int gr_println(gr_srcptr x, gr_ctx_t ctx) - int gr_get_str(char ** s, gr_srcptr x, gr_ctx_t ctx) - int gr_set_str(gr_ptr res, const char * x, gr_ctx_t ctx) - int gr_write_n(gr_stream_t out, gr_srcptr x, slong n, gr_ctx_t ctx) - int gr_get_str_n(char ** s, gr_srcptr x, slong n, gr_ctx_t ctx) - int gr_set(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_set_other(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_set_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_set_si(gr_ptr res, slong x, gr_ctx_t ctx) - int gr_set_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_set_fmpq(gr_ptr res, const fmpq_t x, gr_ctx_t ctx) - int gr_set_d(gr_ptr res, double x, gr_ctx_t ctx) - int gr_get_si(slong * res, gr_srcptr x, gr_ctx_t ctx) - int gr_get_ui(ulong * res, gr_srcptr x, gr_ctx_t ctx) - int gr_get_fmpz(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) - int gr_get_fmpq(fmpq_t res, gr_srcptr x, gr_ctx_t ctx) - int gr_get_d(double * res, gr_srcptr x, gr_ctx_t ctx) - int gr_set_fmpz_2exp_fmpz(gr_ptr res, const fmpz_t a, const fmpz_t b, gr_ctx_t ctx) - int gr_get_fmpz_2exp_fmpz(fmpz_t res1, fmpz_t res2, gr_srcptr x, gr_ctx_t ctx) - int gr_set_fmpz_10exp_fmpz(gr_ptr res, const fmpz_t a, const fmpz_t b, gr_ctx_t ctx) - # int gr_get_fexpr(fexpr_t res, gr_srcptr x, gr_ctx_t ctx) - # int gr_get_fexpr_serialize(fexpr_t res, gr_srcptr x, gr_ctx_t ctx) - # int gr_set_fexpr(gr_ptr res, fexpr_vec_t inputs, gr_vec_t outputs, const fexpr_t x, gr_ctx_t ctx) - int gr_zero(gr_ptr res, gr_ctx_t ctx) - int gr_one(gr_ptr res, gr_ctx_t ctx) - int gr_neg_one(gr_ptr res, gr_ctx_t ctx) - int gr_gen(gr_ptr res, gr_ctx_t ctx) - int gr_gens(gr_vec_t res, gr_ctx_t ctx) - int gr_gens_recursive(gr_vec_t res, gr_ctx_t ctx) - truth_t gr_is_zero(gr_srcptr x, gr_ctx_t ctx) - truth_t gr_is_one(gr_srcptr x, gr_ctx_t ctx) - truth_t gr_is_neg_one(gr_srcptr x, gr_ctx_t ctx) - truth_t gr_equal(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_is_integer(gr_srcptr x, gr_ctx_t ctx) - truth_t gr_is_rational(gr_srcptr x, gr_ctx_t ctx) - int gr_neg(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_add(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_add_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_add_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_add_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_add_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_add_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_other_add(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_sub(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_sub_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_sub_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_sub_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_sub_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_sub_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_other_sub(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_mul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_mul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_mul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_mul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_mul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_mul_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_other_mul(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_addmul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_addmul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_addmul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_addmul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_addmul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_addmul_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_submul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_submul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_submul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_submul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_submul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_submul_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_mul_two(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sqr(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_mul_2exp_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_mul_2exp_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - truth_t gr_is_invertible(gr_srcptr x, gr_ctx_t ctx) - int gr_inv(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_div(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_div_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_div_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_div_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_div_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_div_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_other_div(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_div_nonunique(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_divides(gr_srcptr d, gr_srcptr x, gr_ctx_t ctx) - int gr_divexact(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_divexact_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_divexact_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_divexact_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_divexact_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_other_divexact(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_euclidean_div(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_euclidean_rem(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_euclidean_divrem(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_pow(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_pow_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_pow_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_pow_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_pow_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_pow_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_other_pow(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_is_square(gr_srcptr x, gr_ctx_t ctx) - int gr_sqrt(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_rsqrt(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_gcd(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_lcm(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_canonical_associate(gr_ptr res, gr_ptr u, gr_srcptr x, gr_ctx_t ctx) - int gr_factor(gr_ptr c, gr_vec_t factors, gr_vec_t exponents, gr_srcptr x, int flags, gr_ctx_t ctx) - int gr_numerator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_denominator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_floor(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_ceil(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_trunc(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_nint(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_abs(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_i(gr_ptr res, gr_ctx_t ctx) - int gr_conj(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_re(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_im(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sgn(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_csgn(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_arg(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_pos_inf(gr_ptr res, gr_ctx_t ctx) - int gr_neg_inf(gr_ptr res, gr_ctx_t ctx) - int gr_uinf(gr_ptr res, gr_ctx_t ctx) - int gr_undefined(gr_ptr res, gr_ctx_t ctx) - int gr_unknown(gr_ptr res, gr_ctx_t ctx) - int gr_cmp(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_cmp_other(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_cmpabs(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_cmpabs_other(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - truth_t gr_le(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_lt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_ge(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_gt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_abs_le(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_abs_lt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_abs_ge(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - truth_t gr_abs_gt(gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_min(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_max(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_set_interval_mid_rad(gr_ptr res, gr_srcptr m, gr_srcptr r, gr_ctx_t ctx) - int gr_ctx_fq_prime(fmpz_t p, gr_ctx_t ctx) - int gr_ctx_fq_degree(slong * deg, gr_ctx_t ctx) - int gr_ctx_fq_order(fmpz_t q, gr_ctx_t ctx) - int gr_fq_frobenius(gr_ptr res, gr_srcptr x, slong e, gr_ctx_t ctx) - int gr_fq_multiplicative_order(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) - int gr_fq_norm(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) - int gr_fq_trace(fmpz_t res, gr_srcptr x, gr_ctx_t ctx) - truth_t gr_fq_is_primitive(gr_srcptr x, gr_ctx_t ctx) - int gr_fq_pth_root(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_domains.pxd b/src/flint/flintlib/functions/gr_domains.pxd deleted file mode 100644 index 1fe7fad4..00000000 --- a/src/flint/flintlib/functions/gr_domains.pxd +++ /dev/null @@ -1,74 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_poly_t -from flint.flintlib.types.fmpz cimport fmpz_poly_t -from flint.flintlib.types.gr cimport gr_ctx_t, truth_t -from flint.flintlib.types.mpoly cimport ordering_t - - - -cdef extern from "flint/gr.h": - int gr_ctx_cmp_coercion(gr_ctx_t ctx1, gr_ctx_t ctx2) - truth_t gr_ctx_is_finite(gr_ctx_t ctx) - truth_t gr_ctx_is_multiplicative_group(gr_ctx_t ctx) - truth_t gr_ctx_is_ring(gr_ctx_t ctx) - truth_t gr_ctx_is_commutative_ring(gr_ctx_t ctx) - truth_t gr_ctx_is_integral_domain(gr_ctx_t ctx) - truth_t gr_ctx_is_unique_factorization_domain(gr_ctx_t ctx) - truth_t gr_ctx_is_field(gr_ctx_t ctx) - truth_t gr_ctx_is_algebraically_closed(gr_ctx_t ctx) - truth_t gr_ctx_is_finite_characteristic(gr_ctx_t ctx) - truth_t gr_ctx_is_ordered_ring(gr_ctx_t ctx) - truth_t gr_ctx_is_zero_ring(gr_ctx_t ctx) - truth_t gr_ctx_is_exact(gr_ctx_t ctx) - truth_t gr_ctx_is_canonical(gr_ctx_t ctx) - truth_t gr_ctx_has_real_prec(gr_ctx_t ctx) - int gr_ctx_set_real_prec(gr_ctx_t ctx, slong prec) - int gr_ctx_get_real_prec(slong * prec, gr_ctx_t ctx) - void gr_ctx_init_perm(gr_ctx_t ctx, ulong n) - void gr_ctx_init_psl2z(gr_ctx_t ctx) - int gr_ctx_init_dirichlet_group(gr_ctx_t ctx, ulong q) - void gr_ctx_init_random(gr_ctx_t ctx, flint_rand_t state) - void gr_ctx_init_fmpz(gr_ctx_t ctx) - void gr_ctx_init_fmpq(gr_ctx_t ctx) - void gr_ctx_init_fmpzi(gr_ctx_t ctx) - int gr_ctx_set_is_field(gr_ctx_t ctx, truth_t is_field) - void gr_ctx_init_nmod(gr_ctx_t ctx, ulong n) - void gr_ctx_init_nmod8(gr_ctx_t ctx, unsigned char n) - void gr_ctx_init_nmod32(gr_ctx_t ctx, unsigned int n) - void gr_ctx_init_fmpz_mod(gr_ctx_t ctx, const fmpz_t n) - void gr_ctx_init_fq(gr_ctx_t ctx, const fmpz_t p, slong d, const char * var) - void gr_ctx_init_fq_nmod(gr_ctx_t ctx, ulong p, slong d, const char * var) - void gr_ctx_init_fq_zech(gr_ctx_t ctx, ulong p, slong d, const char * var) - void gr_ctx_init_nf(gr_ctx_t ctx, const fmpq_poly_t poly) - void gr_ctx_init_nf_fmpz_poly(gr_ctx_t ctx, const fmpz_poly_t poly) - void gr_ctx_init_real_qqbar(gr_ctx_t ctx) - void gr_ctx_init_complex_qqbar(gr_ctx_t ctx) - void _gr_ctx_qqbar_set_limits(gr_ctx_t ctx, slong deg_limit, slong bits_limit) - void gr_ctx_init_real_arb(gr_ctx_t ctx, slong prec) - void gr_ctx_init_complex_acb(gr_ctx_t ctx, slong prec) - void gr_ctx_arb_set_prec(gr_ctx_t ctx, slong prec) - slong gr_ctx_arb_get_prec(gr_ctx_t ctx) - void gr_ctx_init_real_ca(gr_ctx_t ctx) - void gr_ctx_init_complex_ca(gr_ctx_t ctx) - void gr_ctx_init_real_algebraic_ca(gr_ctx_t ctx) - void gr_ctx_init_complex_algebraic_ca(gr_ctx_t ctx) - void gr_ctx_ca_set_option(gr_ctx_t ctx, slong option, slong value) - slong gr_ctx_ca_get_option(gr_ctx_t ctx, slong option) - void gr_ctx_init_complex_extended_ca(gr_ctx_t ctx) - void gr_ctx_init_real_float_arf(gr_ctx_t ctx, slong prec) - void gr_ctx_init_complex_float_acf(gr_ctx_t ctx, slong prec) - void gr_ctx_init_vector_gr_vec(gr_ctx_t ctx, gr_ctx_t base_type) - void gr_ctx_init_vector_space_gr_vec(gr_ctx_t ctx, gr_ctx_t base_type, slong n) - void gr_ctx_init_matrix_domain(gr_ctx_t ctx, gr_ctx_t base_ring) - void gr_ctx_init_matrix_space(gr_ctx_t ctx, gr_ctx_t base_ring, slong n, slong m) - void gr_ctx_init_matrix_ring(gr_ctx_t ctx, gr_ctx_t base_ring, slong n) - void gr_ctx_init_fmpz_poly(gr_ctx_t ctx) - void gr_ctx_init_fmpq_poly(gr_ctx_t ctx) - void gr_ctx_init_gr_poly(gr_ctx_t ctx, gr_ctx_t base_ring) - void gr_ctx_init_fmpz_mpoly(gr_ctx_t ctx, slong nvars, const ordering_t ord) - void gr_ctx_init_gr_mpoly(gr_ctx_t ctx, gr_ctx_t base_ring, slong nvars, const ordering_t ord) - void gr_ctx_init_series_mod_gr_poly(gr_ctx_t ctx, gr_ctx_t base_ring, slong n) - void gr_ctx_init_gr_series(gr_ctx_t ctx, gr_ctx_t base_ring, slong prec) - void gr_ctx_init_gr_fraction(gr_ctx_t ctx, gr_ctx_t domain, int flags) - void gr_ctx_init_fmpz_mpoly_q(gr_ctx_t ctx, slong nvars, const ordering_t ord) - void gr_ctx_init_fexpr(gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_generic.pxd b/src/flint/flintlib/functions/gr_generic.pxd deleted file mode 100644 index f6dd87f3..00000000 --- a/src/flint/flintlib/functions/gr_generic.pxd +++ /dev/null @@ -1,215 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mpoly_ctx_t, fmpz_mpoly_t, fmpz_poly_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_ptr, gr_srcptr, gr_stream_t, gr_vec_t, truth_t - - -# .. macro :: GR_PARSE_BALANCE_ADDITIONS -# .. macro :: GR_PARSE_RING_EXPONENTS - -cdef extern from "flint/gr_generic.h": - void gr_generic_init(void) - void gr_generic_clear(void) - void gr_generic_swap(void) - void gr_generic_randtest(void) - void gr_generic_write(void) - void gr_generic_zero(void) - void gr_generic_one(void) - void gr_generic_equal(void) - void gr_generic_set(void) - void gr_generic_set_si(void) - void gr_generic_set_ui(void) - void gr_generic_set_fmpz(void) - void gr_generic_neg(void) - void gr_generic_add(void) - void gr_generic_sub(void) - void gr_generic_mul(void) - void gr_generic_ctx_clear(gr_ctx_t ctx) - void gr_generic_set_shallow(gr_ptr res, gr_srcptr x, const gr_ctx_t ctx) - int gr_generic_write_n(gr_stream_t out, gr_srcptr x, slong n, gr_ctx_t ctx) - int gr_generic_randtest_not_zero(gr_ptr x, flint_rand_t state, gr_ctx_t ctx) - int gr_generic_randtest_small(gr_ptr x, flint_rand_t state, gr_ctx_t ctx) - truth_t gr_generic_is_zero(gr_srcptr x, gr_ctx_t ctx) - truth_t gr_generic_is_one(gr_srcptr x, gr_ctx_t ctx) - truth_t gr_generic_is_neg_one(gr_srcptr x, gr_ctx_t ctx) - int gr_generic_neg_one(gr_ptr res, gr_ctx_t ctx) - int gr_generic_set_other(gr_ptr res, gr_srcptr x, gr_ctx_t xctx, gr_ctx_t ctx) - int gr_generic_set_fmpq(gr_ptr res, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_set_str_expr(gr_ptr res, const char * s, int flags, gr_ctx_t ctx) - int gr_generic_set_str(gr_ptr res, const char * s, gr_ctx_t ctx) - int gr_generic_set_str_balance_additions(gr_ptr res, const char * s, gr_ctx_t ctx) - int gr_generic_set_str_ring_exponents(gr_ptr res, const char * s, gr_ctx_t ctx) - int gr_generic_add_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_add_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_generic_add_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_add_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_add_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_other_add(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_sub_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_generic_sub_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_sub_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_sub_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_sub_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_other_sub(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_mul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_mul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_generic_mul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_mul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_mul_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_other_mul(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_addmul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_addmul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_generic_addmul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_addmul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_addmul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_addmul_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_submul(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_submul_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_generic_submul_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_submul_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_submul_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_submul_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_mul_two(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_generic_sqr(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_generic_mul_2exp_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_mul_2exp_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_set_fmpz_2exp_fmpz(gr_ptr res, const fmpz_t x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_get_fmpz_2exp_fmpz(fmpz_t res1, fmpz_t res2, gr_ptr x, gr_ctx_t ctx) - int gr_generic_inv(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - truth_t gr_generic_is_invertible(gr_srcptr x, gr_ctx_t ctx) - int gr_generic_div_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t y, gr_ctx_t ctx) - int gr_generic_div_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_generic_div_si(gr_ptr res, gr_srcptr x, slong y, gr_ctx_t ctx) - int gr_generic_div_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_div_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_other_div(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_divexact(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_pow_fmpz_sliding(gr_ptr f, gr_srcptr g, const fmpz_t pow, gr_ctx_t ctx) - int gr_generic_pow_ui_sliding(gr_ptr f, gr_srcptr g, ulong pow, gr_ctx_t ctx) - int gr_generic_pow_fmpz_binexp(gr_ptr res, gr_srcptr x, const fmpz_t exp, gr_ctx_t ctx) - int gr_generic_pow_ui_binexp(gr_ptr res, gr_srcptr x, ulong e, gr_ctx_t ctx) - int gr_generic_pow_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t e, gr_ctx_t ctx) - int gr_generic_pow_si(gr_ptr res, gr_srcptr x, slong e, gr_ctx_t ctx) - int gr_generic_pow_ui(gr_ptr res, gr_srcptr x, ulong e, gr_ctx_t ctx) - int gr_generic_pow_fmpq(gr_ptr res, gr_srcptr x, const fmpq_t y, gr_ctx_t ctx) - int gr_generic_pow_other(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_other_pow(gr_ptr res, gr_srcptr x, gr_ctx_t x_ctx, gr_srcptr y, gr_ctx_t ctx) - int _gr_fmpz_poly_evaluate_horner(gr_ptr res, const fmpz_struct * f, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_fmpz_poly_evaluate_horner(gr_ptr res, const fmpz_poly_t f, gr_srcptr x, gr_ctx_t ctx) - int _gr_fmpz_poly_evaluate_rectangular(gr_ptr res, const fmpz_struct * f, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_fmpz_poly_evaluate_rectangular(gr_ptr res, const fmpz_poly_t f, gr_srcptr x, gr_ctx_t ctx) - int _gr_fmpz_poly_evaluate(gr_ptr res, const fmpz_struct * f, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_fmpz_poly_evaluate(gr_ptr res, const fmpz_poly_t f, gr_srcptr x, gr_ctx_t ctx) - int gr_fmpz_mpoly_evaluate_iter(gr_ptr res, const fmpz_mpoly_t f, gr_srcptr x, const fmpz_mpoly_ctx_t mctx, gr_ctx_t ctx) - int gr_fmpz_mpoly_evaluate_horner(gr_ptr res, const fmpz_mpoly_t f, gr_srcptr x, const fmpz_mpoly_ctx_t mctx, gr_ctx_t ctx) - int gr_fmpz_mpoly_evaluate(gr_ptr res, const fmpz_mpoly_t f, gr_srcptr x, const fmpz_mpoly_ctx_t mctx, gr_ctx_t ctx) - truth_t gr_generic_is_square(gr_srcptr x, gr_ctx_t ctx) - int gr_generic_sqrt(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_generic_rsqrt(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_generic_numerator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_generic_denominator(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_generic_cmp(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_cmpabs(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_generic_cmp_other(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_cmpabs_other(int * res, gr_srcptr x, gr_srcptr y, gr_ctx_t y_ctx, gr_ctx_t ctx) - int gr_generic_bernoulli_ui(gr_ptr res, ulong n, gr_ctx_t ctx) - int gr_generic_bernoulli_fmpz(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_generic_bernoulli_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_generic_eulernum_ui(gr_ptr res, ulong n, gr_ctx_t ctx) - int gr_generic_eulernum_fmpz(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_generic_eulernum_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_generic_stirling_s1u_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_generic_stirling_s1_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_generic_stirling_s2_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_generic_stirling_s1u_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - int gr_generic_stirling_s1_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - int gr_generic_stirling_s2_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - void gr_generic_vec_init(gr_ptr vec, slong len, gr_ctx_t ctx) - void gr_generic_vec_clear(gr_ptr vec, slong len, gr_ctx_t ctx) - void gr_generic_vec_swap(gr_ptr vec1, gr_ptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_zero(gr_ptr vec, slong len, gr_ctx_t ctx) - int gr_generic_vec_set(gr_ptr res, gr_srcptr src, slong len, gr_ctx_t ctx) - int gr_generic_vec_neg(gr_ptr res, gr_srcptr src, slong len, gr_ctx_t ctx) - int gr_generic_vec_normalise(slong * res, gr_srcptr vec, slong len, gr_ctx_t ctx) - slong gr_generic_vec_normalise_weak(gr_srcptr vec, slong len, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar_2exp_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_scalar_addmul(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_scalar_submul(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_scalar_addmul_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_scalar_submul_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - truth_t gr_generic_vec_equal(gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_is_zero(gr_srcptr vec, slong len, gr_ctx_t ctx) - int gr_generic_vec_dot(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_dot_rev(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_dot_ui(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const ulong * vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_dot_si(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const slong * vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_dot_fmpz(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const fmpz_struct * vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_set_powers(gr_ptr res, gr_srcptr x, slong len, gr_ctx_t ctx) - int gr_generic_vec_reciprocals(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_generic_vec_add(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int gr_generic_vec_sub(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int gr_generic_vec_mul(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int gr_generic_vec_div(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int gr_generic_vec_divexact(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int gr_generic_vec_pow(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int gr_generic_vec_add_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_sub_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_div_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_divexact_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_pow_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_generic_vec_add_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_sub_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_div_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_divexact_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_pow_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int gr_generic_vec_add_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int gr_generic_vec_sub_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int gr_generic_vec_div_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int gr_generic_vec_divexact_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int gr_generic_vec_pow_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int gr_generic_vec_add_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int gr_generic_vec_sub_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int gr_generic_vec_div_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int gr_generic_vec_divexact_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int gr_generic_vec_pow_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int gr_generic_vec_add_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int gr_generic_vec_sub_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int gr_generic_vec_div_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int gr_generic_vec_divexact_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int gr_generic_vec_pow_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int gr_generic_scalar_add_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_sub_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_mul_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_div_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_divexact_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_pow_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_vec_add_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int gr_generic_vec_sub_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int gr_generic_vec_mul_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int gr_generic_vec_div_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int gr_generic_vec_divexact_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int gr_generic_vec_pow_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int gr_generic_other_add_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int gr_generic_other_sub_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int gr_generic_other_mul_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int gr_generic_other_div_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int gr_generic_other_divexact_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int gr_generic_other_pow_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int gr_generic_vec_add_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int gr_generic_vec_sub_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int gr_generic_vec_mul_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int gr_generic_vec_div_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int gr_generic_vec_divexact_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int gr_generic_vec_pow_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int gr_generic_scalar_other_add_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_other_sub_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_other_mul_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_other_div_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_other_divexact_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_scalar_other_pow_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int gr_generic_poly_factor_roots( gr_ptr c, gr_vec_t fac, gr_vec_t mult, gr_srcptr elt, int flags, gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_implementing.pxd b/src/flint/flintlib/functions/gr_implementing.pxd deleted file mode 100644 index c97fd3aa..00000000 --- a/src/flint/flintlib/functions/gr_implementing.pxd +++ /dev/null @@ -1,14 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.gr cimport gr_ctx_t, gr_funcptr, truth_t - -# unknown type gr_method_tab_input - - -cdef extern from "flint/gr_implementing.h": - # void gr_method_tab_init(gr_funcptr * methods, gr_method_tab_input * tab) - int gr_not_implemented(void) - int gr_not_in_domain(void) - truth_t gr_generic_ctx_predicate(gr_ctx_t ctx) - truth_t gr_generic_ctx_predicate_true(gr_ctx_t ctx) - truth_t gr_generic_ctx_predicate_false(gr_ctx_t ctx) - void gr_test_ring(gr_ctx_t R, slong iters, int test_flags) diff --git a/src/flint/flintlib/functions/gr_mat.pxd b/src/flint/flintlib/functions/gr_mat.pxd deleted file mode 100644 index e17716c2..00000000 --- a/src/flint/flintlib/functions/gr_mat.pxd +++ /dev/null @@ -1,236 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_mat_t, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_mat_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_mat_t, gr_poly_t, gr_ptr, gr_srcptr, gr_stream_t, gr_vec_t, truth_t - -# unknown type gr_method_binary_op -# unknown type gr_method_binary_predicate -# unknown type gr_method_mat_binary_op -# unknown type gr_method_mat_binary_op_with_flag -# unknown type gr_method_mat_lu_op -# unknown type gr_method_mat_unary_op_get_scalar -# unknown type gr_method_unary_op -# unknown type gr_method_unary_predicate -# unknown type gr_method_vec_op -# unknown type gr_method_vec_scalar_op - -# .. macro:: GR_MAT_ENTRY(mat, i, j, sz) -# .. macro:: gr_mat_nrows(mat, ctx) -# .. macro:: gr_mat_ncols(mat, ctx) - -cdef extern from "flint/gr_mat.h": - gr_ptr gr_mat_entry_ptr(gr_mat_t mat, slong i, slong j, gr_ctx_t ctx) - void gr_mat_init(gr_mat_t mat, slong rows, slong cols, gr_ctx_t ctx) - int gr_mat_init_set(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - void gr_mat_clear(gr_mat_t mat, gr_ctx_t ctx) - void gr_mat_swap(gr_mat_t mat1, gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_swap_entrywise(gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - void gr_mat_window_init(gr_mat_t window, const gr_mat_t mat, slong r1, slong c1, slong r2, slong c2, gr_ctx_t ctx) - void gr_mat_window_clear(gr_mat_t window, gr_ctx_t ctx) - int gr_mat_write(gr_stream_t out, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_print(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_equal(const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - truth_t gr_mat_is_zero(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_one(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_neg_one(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_scalar(const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_zero(gr_mat_t res, gr_ctx_t ctx) - int gr_mat_one(gr_mat_t res, gr_ctx_t ctx) - int gr_mat_set(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_set_fmpz_mat(gr_mat_t res, const fmpz_mat_t mat, gr_ctx_t ctx) - int gr_mat_set_fmpq_mat(gr_mat_t res, const fmpq_mat_t mat, gr_ctx_t ctx) - int gr_mat_set_gr_mat_other(gr_mat_t res, const gr_mat_t mat, gr_ctx_t mat_ctx, gr_ctx_t ctx) - int gr_mat_set_scalar(gr_mat_t res, gr_srcptr c, gr_ctx_t ctx) - int gr_mat_set_ui(gr_mat_t res, ulong c, gr_ctx_t ctx) - int gr_mat_set_si(gr_mat_t res, slong c, gr_ctx_t ctx) - int gr_mat_set_fmpz(gr_mat_t res, const fmpz_t c, gr_ctx_t ctx) - int gr_mat_set_fmpq(gr_mat_t res, const fmpq_t c, gr_ctx_t ctx) - int gr_mat_concat_horizontal(gr_mat_t res, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_concat_vertical(gr_mat_t res, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_transpose(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_swap_rows(gr_mat_t mat, slong * perm, slong r, slong s, gr_ctx_t ctx) - int gr_mat_swap_cols(gr_mat_t mat, slong * perm, slong r, slong s, gr_ctx_t ctx) - int gr_mat_invert_rows(gr_mat_t mat, slong * perm, gr_ctx_t ctx) - int gr_mat_invert_cols(gr_mat_t mat, slong * perm, gr_ctx_t ctx) - truth_t gr_mat_is_empty(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_square(const gr_mat_t mat, gr_ctx_t ctx) - # int gr_mat_entrywise_unary_op(gr_mat_t res, gr_method_unary_op f, const gr_mat_t mat, gr_ctx_t ctx) - # int gr_mat_entrywise_binary_op(gr_mat_t res, gr_method_binary_op f, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - # int gr_mat_entrywise_binary_op_scalar(gr_mat_t res, gr_method_binary_op f, const gr_mat_t mat, gr_srcptr c, gr_ctx_t ctx) - # truth_t gr_mat_entrywise_unary_predicate_all(gr_method_unary_predicate f, const gr_mat_t mat, gr_ctx_t ctx) - # truth_t gr_mat_entrywise_unary_predicate_any(gr_method_unary_predicate f, const gr_mat_t mat, gr_ctx_t ctx) - # truth_t gr_mat_entrywise_binary_predicate_all(gr_method_binary_predicate f, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_norm_max(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_norm_1(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_norm_inf(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_norm_frobenius(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_neg(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_add(gr_mat_t res, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_sub(gr_mat_t res, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_add_scalar(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t ctx) - int gr_mat_scalar_add(gr_mat_t res, gr_srcptr x, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_add_ui(gr_mat_t res, const gr_mat_t mat, ulong x, gr_ctx_t ctx) - int gr_mat_add_si(gr_mat_t res, const gr_mat_t mat, slong x, gr_ctx_t ctx) - int gr_mat_add_fmpz(gr_mat_t res, const gr_mat_t mat, const fmpz_t x, gr_ctx_t ctx) - int gr_mat_add_fmpq(gr_mat_t res, const gr_mat_t mat, const fmpq_t x, gr_ctx_t ctx) - int gr_mat_add_scalar_other(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_mat_scalar_other_add(gr_mat_t res, gr_srcptr x, gr_ctx_t x_ctx, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_sub_scalar(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t ctx) - int gr_mat_scalar_sub(gr_mat_t res, gr_srcptr x, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_sub_ui(gr_mat_t res, const gr_mat_t mat, ulong x, gr_ctx_t ctx) - int gr_mat_sub_si(gr_mat_t res, const gr_mat_t mat, slong x, gr_ctx_t ctx) - int gr_mat_sub_fmpz(gr_mat_t res, const gr_mat_t mat, const fmpz_t x, gr_ctx_t ctx) - int gr_mat_sub_fmpq(gr_mat_t res, const gr_mat_t mat, const fmpq_t x, gr_ctx_t ctx) - int gr_mat_sub_scalar_other(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_mat_scalar_other_sub(gr_mat_t res, gr_srcptr x, gr_ctx_t x_ctx, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_mul_scalar(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t ctx) - int gr_mat_scalar_mul(gr_mat_t res, gr_srcptr x, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_mul_ui(gr_mat_t res, const gr_mat_t mat, ulong x, gr_ctx_t ctx) - int gr_mat_mul_si(gr_mat_t res, const gr_mat_t mat, slong x, gr_ctx_t ctx) - int gr_mat_mul_fmpz(gr_mat_t res, const gr_mat_t mat, const fmpz_t x, gr_ctx_t ctx) - int gr_mat_mul_fmpq(gr_mat_t res, const gr_mat_t mat, const fmpq_t x, gr_ctx_t ctx) - int gr_mat_mul_scalar_other(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_mat_scalar_other_mul(gr_mat_t res, gr_srcptr x, gr_ctx_t x_ctx, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_div_scalar(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t ctx) - int gr_mat_div_scalar_other(gr_mat_t res, const gr_mat_t mat, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_mat_div_ui(gr_mat_t res, const gr_mat_t mat, ulong x, gr_ctx_t ctx) - int gr_mat_div_si(gr_mat_t res, const gr_mat_t mat, slong x, gr_ctx_t ctx) - int gr_mat_div_fmpz(gr_mat_t res, const gr_mat_t mat, const fmpz_t x, gr_ctx_t ctx) - int gr_mat_div_fmpq(gr_mat_t res, const gr_mat_t mat, const fmpq_t x, gr_ctx_t ctx) - int gr_mat_addmul_scalar(gr_mat_t res, const gr_mat_t mat, gr_srcptr c, gr_ctx_t ctx) - int gr_mat_submul_scalar(gr_mat_t res, const gr_mat_t mat, gr_srcptr c, gr_ctx_t ctx) - int gr_mat_mul(gr_mat_t res, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_mul_generic(gr_mat_t C, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_mul_classical(gr_mat_t res, const gr_mat_t mat1, const gr_mat_t mat2, gr_ctx_t ctx) - int gr_mat_mul_strassen(gr_mat_t C, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_mul_waksman(gr_mat_t C, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_mul_rosowski(gr_mat_t C, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_sqr(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_pow_ui(gr_mat_t res, const gr_mat_t mat, ulong e, gr_ctx_t ctx) - int gr_mat_pow_si(gr_mat_t res, const gr_mat_t mat, slong e, gr_ctx_t ctx) - int gr_mat_pow_fmpz(gr_mat_t res, const gr_mat_t mat, const fmpz_t e, gr_ctx_t ctx) - int _gr_mat_gr_poly_evaluate(gr_mat_t res, gr_srcptr poly, slong len, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_gr_poly_evaluate(gr_mat_t res, const gr_poly_t poly, const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_upper_triangular(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_lower_triangular(const gr_mat_t mat, gr_ctx_t ctx) - truth_t gr_mat_is_diagonal(const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_mul_diag(gr_mat_t res, const gr_mat_t A, const gr_vec_t D, gr_ctx_t ctx) - int gr_mat_diag_mul(gr_mat_t res, const gr_vec_t D, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_find_nonzero_pivot_large_abs(slong * pivot_row, gr_mat_t mat, slong start_row, slong end_row, slong column, gr_ctx_t ctx) - int gr_mat_find_nonzero_pivot_generic(slong * pivot_row, gr_mat_t mat, slong start_row, slong end_row, slong column, gr_ctx_t ctx) - int gr_mat_find_nonzero_pivot(slong * pivot_row, gr_mat_t mat, slong start_row, slong end_row, slong column, gr_ctx_t ctx) - int gr_mat_lu_classical(slong * rank, slong * P, gr_mat_t LU, const gr_mat_t A, int rank_check, gr_ctx_t ctx) - int gr_mat_lu_recursive(slong * rank, slong * P, gr_mat_t LU, const gr_mat_t A, int rank_check, gr_ctx_t ctx) - int gr_mat_lu_generic(slong * rank, slong * P, gr_mat_t LU, const gr_mat_t A, int rank_check, gr_ctx_t ctx) - int gr_mat_lu(slong * rank, slong * P, gr_mat_t LU, const gr_mat_t A, int rank_check, gr_ctx_t ctx) - int gr_mat_fflu(slong * rank, slong * P, gr_mat_t LU, gr_ptr den, const gr_mat_t A, int rank_check, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_tril_classical(gr_mat_t X, const gr_mat_t L, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_tril_recursive(gr_mat_t X, const gr_mat_t L, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_tril_generic(gr_mat_t X, const gr_mat_t L, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_tril(gr_mat_t X, const gr_mat_t L, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_triu_classical(gr_mat_t X, const gr_mat_t U, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_triu_recursive(gr_mat_t X, const gr_mat_t U, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_triu_generic(gr_mat_t X, const gr_mat_t U, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_triu(gr_mat_t X, const gr_mat_t U, const gr_mat_t B, int unit, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_fflu(gr_mat_t X, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_lu(gr_mat_t X, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_nonsingular_solve(gr_mat_t X, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_fflu_precomp(gr_mat_t X, const slong * perm, const gr_mat_t LU, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_lu_precomp(gr_mat_t X, const slong * perm, const gr_mat_t LU, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_den_fflu(gr_mat_t X, gr_ptr den, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_nonsingular_solve_den(gr_mat_t X, gr_ptr den, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_solve_field(gr_mat_t X, const gr_mat_t A, const gr_mat_t B, gr_ctx_t ctx) - int gr_mat_det_fflu(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_det_berkowitz(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_det_lu(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_det_cofactor(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_det_generic_field(gr_ptr res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_det_generic_integral_domain(gr_ptr res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_det_generic(gr_ptr res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_det(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_trace(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_rank_fflu(slong * rank, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_rank_lu(slong * rank, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_rank(slong * rank, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_rref_lu(slong * rank, gr_mat_t R, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_rref_fflu(slong * rank, gr_mat_t R, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_rref(slong * rank, gr_mat_t R, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_rref_den_fflu(slong * rank, gr_mat_t R, gr_ptr den, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_rref_den(slong * rank, gr_mat_t R, gr_ptr den, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_nullspace(gr_mat_t X, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_nullspace_from_rref(gr_mat_t X, const gr_mat_t A, gr_srcptr Aden, slong rank, gr_ctx_t ctx) - int gr_mat_nullspace_no_resize(slong * nullity, gr_mat_t X, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_inv(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_adjugate_charpoly(gr_mat_t adj, gr_ptr det, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_adjugate_cofactor(gr_mat_t adj, gr_ptr det, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_adjugate(gr_mat_t adj, gr_ptr det, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_generic(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_generic(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_berkowitz(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_berkowitz(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_danilevsky_inplace(gr_ptr res, gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_danilevsky(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_danilevsky(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_gauss(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_gauss(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_householder(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_householder(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_faddeev(gr_ptr res, gr_mat_t adj, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_faddeev(gr_poly_t res, gr_mat_t adj, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_faddeev_bsgs(gr_ptr res, gr_mat_t adj, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_faddeev_bsgs(gr_poly_t res, gr_mat_t adj, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_charpoly_from_hessenberg(gr_ptr res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_charpoly_from_hessenberg(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_minpoly_field(gr_poly_t res, const gr_mat_t mat, gr_ctx_t ctx) - int _gr_mat_companion(gr_mat_t res, gr_srcptr poly, gr_ctx_t ctx) - int gr_mat_companion(gr_mat_t res, const gr_poly_t poly, gr_ctx_t ctx) - int _gr_mat_companion_fraction(gr_mat_t res_num, gr_ptr res_den, gr_srcptr poly, gr_ctx_t ctx) - int gr_mat_companion_fraction(gr_mat_t res_num, gr_ptr res_den, const gr_poly_t poly, gr_ctx_t ctx) - int gr_mat_apply_row_similarity(gr_mat_t M, slong r, gr_ptr d, gr_ctx_t ctx) - int gr_mat_eigenvalues(gr_vec_t lambda_, gr_vec_t mult, const gr_mat_t mat, int flags, gr_ctx_t ctx) - int gr_mat_eigenvalues_other(gr_vec_t lambda_, gr_vec_t mult, const gr_mat_t mat, gr_ctx_t mat_ctx, int flags, gr_ctx_t ctx) - int gr_mat_diagonalization_precomp(gr_vec_t D, gr_mat_t L, gr_mat_t R, const gr_mat_t A, const gr_vec_t eigenvalues, const gr_vec_t mult, gr_ctx_t ctx) - int gr_mat_diagonalization_generic(gr_vec_t D, gr_mat_t L, gr_mat_t R, const gr_mat_t A, int flags, gr_ctx_t ctx) - int gr_mat_diagonalization(gr_vec_t D, gr_mat_t L, gr_mat_t R, const gr_mat_t A, int flags, gr_ctx_t ctx) - int gr_mat_set_jordan_blocks(gr_mat_t mat, const gr_vec_t lambda_, slong num_blocks, slong * block_lambda, slong * block_size, gr_ctx_t ctx) - int gr_mat_jordan_blocks(gr_vec_t lambda_, slong * num_blocks, slong * block_lambda, slong * block_size, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_jordan_transformation(gr_mat_t mat, const gr_vec_t lambda_, slong num_blocks, slong * block_lambda, slong * block_size, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_jordan_form(gr_mat_t J, gr_mat_t P, const gr_mat_t A, gr_ctx_t ctx) - # int gr_mat_func_jordan(gr_mat_t res, const gr_mat_t A, gr_method_vec_op jet_func, gr_ctx_t ctx) - # int gr_mat_func_param_jordan(gr_mat_t res, const gr_mat_t A, gr_method_vec_scalar_op jet_func, gr_srcptr c, gr_ctx_t ctx) - int gr_mat_exp_jordan(gr_mat_t res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_exp(gr_mat_t res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_log_jordan(gr_mat_t res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_log(gr_mat_t res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_pow_scalar_jordan(gr_mat_t res, const gr_mat_t A, gr_srcptr c, gr_ctx_t ctx) - int gr_mat_pow_scalar(gr_mat_t res, const gr_mat_t A, gr_srcptr c, gr_ctx_t ctx) - int gr_mat_pow_fmpq_jordan(gr_mat_t res, const gr_mat_t mat, const fmpq_t exp, gr_ctx_t ctx) - int gr_mat_pow_fmpq(gr_mat_t res, const gr_mat_t mat, const fmpq_t exp, gr_ctx_t ctx) - int gr_mat_sqrt(gr_mat_t res, const gr_mat_t A, gr_ctx_t ctx) - int gr_mat_rsqrt(gr_mat_t res, const gr_mat_t A, gr_ctx_t ctx) - truth_t gr_mat_is_hessenberg(const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_hessenberg_gauss(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_hessenberg_householder(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_hessenberg(gr_mat_t res, const gr_mat_t mat, gr_ctx_t ctx) - int gr_mat_randtest(gr_mat_t res, flint_rand_t state, gr_ctx_t ctx) - int gr_mat_randops(gr_mat_t mat, flint_rand_t state, slong count, gr_ctx_t ctx) - int gr_mat_randpermdiag(int * parity, gr_mat_t mat, flint_rand_t state, gr_ptr diag, slong n, gr_ctx_t ctx) - int gr_mat_randrank(gr_mat_t mat, flint_rand_t state, slong rank, gr_ctx_t ctx) - int gr_mat_randsimilar(gr_mat_t mat, flint_rand_t state, slong opcount, gr_ctx_t ctx) - int gr_mat_ones(gr_mat_t res, gr_ctx_t ctx) - int gr_mat_pascal(gr_mat_t res, int triangular, gr_ctx_t ctx) - int gr_mat_stirling(gr_mat_t res, int kind, gr_ctx_t ctx) - int gr_mat_hilbert(gr_mat_t res, gr_ctx_t ctx) - int gr_mat_hadamard(gr_mat_t res, gr_ctx_t ctx) - int gr_mat_reduce_row_generic(slong * column, gr_mat_t A, slong * P, slong * L, slong m, gr_ctx_t ctx) - int gr_mat_reduce_row(slong * column, gr_mat_t A, slong * P, slong * L, slong m, gr_ctx_t ctx) - # void gr_mat_test_mul(gr_method_mat_binary_op mul_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_lu(gr_method_mat_lu_op lu_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_det(gr_method_mat_unary_op_get_scalar det_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_charpoly(gr_method_mat_unary_op_get_scalar charpoly_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_nonsingular_solve_tril(gr_method_mat_binary_op_with_flag solve_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_nonsingular_solve_triu(gr_method_mat_binary_op_with_flag solve_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_approx_mul_max_norm(gr_method_mat_binary_op mul_impl, gr_srcptr rel_tol, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void gr_mat_test_approx_mul_pos_entrywise_accurate(gr_method_mat_binary_op mul_impl, gr_srcptr rel_tol, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_mpoly.pxd b/src/flint/flintlib/functions/gr_mpoly.pxd deleted file mode 100644 index d9988ae6..00000000 --- a/src/flint/flintlib/functions/gr_mpoly.pxd +++ /dev/null @@ -1,87 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_mpoly_t, gr_ptr, gr_srcptr, gr_stream_t, gr_vec_t, truth_t -from flint.flintlib.types.mpoly cimport ordering_t - -# unknown type gr_mpoly_ctx_t - -# .. macro:: GR_MPOLY_MCTX(ctx) -# .. macro:: GR_MPOLY_CCTX(ctx) -# .. macro:: GR_MPOLY_VARS(ctx) -# .. macro:: GR_MPOLY_NVARS(ctx) - -cdef extern from "flint/gr_mpoly.h": - # void gr_mpoly_ctx_init(gr_mpoly_ctx_t ctx, gr_ctx_t base_ring, slong nvars, const ordering_t ord) - # void gr_mpoly_ctx_clear(gr_mpoly_ctx_t ctx) - # void gr_mpoly_ctx_init_rand(gr_mpoly_ctx_t ctx, flint_rand_t state, gr_ctx_t base_ring, slong max_nvars) - # int gr_mpoly_ctx_set_gen_names(gr_mpoly_ctx_t ctx, const char ** s) - # int gr_mpoly_ctx_write(gr_stream_t out, gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_ctx_is_ring(gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_ctx_is_zero_ring(gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_ctx_is_commutative_ring(gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_ctx_is_integral_domain(gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_ctx_is_field(gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_ctx_is_threadsafe(gr_mpoly_ctx_t ctx) - # void gr_mpoly_init(gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # void gr_mpoly_init3(gr_mpoly_t A, slong alloc, flint_bitcnt_t bits, gr_mpoly_ctx_t ctx) - # void gr_mpoly_init2(gr_mpoly_t A, slong alloc, gr_mpoly_ctx_t ctx) - # void gr_mpoly_clear(gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # void gr_mpoly_swap(gr_mpoly_t A, gr_mpoly_t B, gr_mpoly_ctx_t ctx) - # void gr_mpoly_set_shallow(gr_mpoly_t A, const gr_mpoly_t B, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set(gr_mpoly_t A, const gr_mpoly_t B, gr_mpoly_ctx_t ctx) - # int gr_mpoly_zero(gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_is_zero(const gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # slong gr_mpoly_length(const gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # int gr_mpoly_gen(gr_mpoly_t A, slong var, gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_is_gen(const gr_mpoly_t A, slong var, gr_mpoly_ctx_t ctx) - # int gr_mpoly_gens(gr_vec_t res, gr_mpoly_ctx_t ctx) - # int gr_mpoly_gens_recursive(gr_vec_t vec, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_scalar(gr_mpoly_t A, gr_srcptr c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_ui(gr_mpoly_t A, ulong c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_si(gr_mpoly_t A, slong c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_fmpz(gr_mpoly_t A, const fmpz_t c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_fmpq(gr_mpoly_t A, const fmpq_t c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_other(gr_mpoly_t res, gr_srcptr A, gr_ctx_t A_ctx, gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_equal(const gr_mpoly_t A, const gr_mpoly_t B, gr_mpoly_ctx_t ctx) - # int gr_mpoly_randtest_bits(gr_mpoly_t A, flint_rand_t state, slong length, flint_bitcnt_t exp_bits, gr_mpoly_ctx_t ctx) - # int gr_mpoly_write_pretty(gr_stream_t out, const gr_mpoly_t A, const char ** x, gr_mpoly_ctx_t ctx) - # int gr_mpoly_print_pretty(const gr_mpoly_t A, const char ** x, gr_mpoly_ctx_t ctx) - # int gr_mpoly_get_coeff_scalar_fmpz(gr_ptr c, const gr_mpoly_t A, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_get_coeff_scalar_ui(gr_ptr c, const gr_mpoly_t A, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_scalar_fmpz(gr_mpoly_t A, gr_srcptr c, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_ui_fmpz(gr_mpoly_t A, ulong c, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_si_fmpz(gr_mpoly_t A, slong c, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_fmpz_fmpz(gr_mpoly_t A, const fmpz_t c, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_fmpq_fmpz(gr_mpoly_t A, const fmpq_t c, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_scalar_ui(gr_mpoly_t poly, gr_srcptr c, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_ui_ui(gr_mpoly_t A, ulong c, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_si_ui(gr_mpoly_t A, slong c, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_fmpz_ui(gr_mpoly_t A, const fmpz_t c, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_set_coeff_fmpq_ui(gr_mpoly_t A, const fmpq_t c, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_neg(gr_mpoly_t A, const gr_mpoly_t B, gr_mpoly_ctx_t ctx) - # int gr_mpoly_add(gr_mpoly_t A, const gr_mpoly_t B, const gr_mpoly_t C, gr_mpoly_ctx_t ctx) - # int gr_mpoly_sub(gr_mpoly_t A, const gr_mpoly_t B, const gr_mpoly_t C, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul(gr_mpoly_t A, const gr_mpoly_t B, const gr_mpoly_t C, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_johnson(gr_mpoly_t A, const gr_mpoly_t B, const gr_mpoly_t C, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_monomial(gr_mpoly_t A, const gr_mpoly_t B, const gr_mpoly_t C, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_scalar(gr_mpoly_t A, const gr_mpoly_t B, gr_srcptr c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_si(gr_mpoly_t A, const gr_mpoly_t B, slong c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_ui(gr_mpoly_t A, const gr_mpoly_t B, ulong c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_fmpz(gr_mpoly_t A, const gr_mpoly_t B, const fmpz_t c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_mul_fmpq(gr_mpoly_t A, const gr_mpoly_t B, const fmpq_t c, gr_mpoly_ctx_t ctx) - # int gr_mpoly_inv(gr_mpoly_t res, const gr_mpoly_t src, gr_mpoly_ctx_t ctx) - # int gr_mpoly_canonical_associate(gr_mpoly_t res, gr_mpoly_t u, const gr_mpoly_t src, gr_mpoly_ctx_t ctx) - # void _gr_mpoly_fit_length(gr_ptr * coeffs, slong * coeffs_alloc, ulong ** exps, slong * exps_alloc, slong N, slong length, gr_mpoly_ctx_t ctx) - # void gr_mpoly_fit_length(gr_mpoly_t A, slong len, gr_mpoly_ctx_t ctx) - # void gr_mpoly_fit_bits(gr_mpoly_t A, flint_bitcnt_t bits, gr_mpoly_ctx_t ctx) - # void gr_mpoly_fit_length_fit_bits(gr_mpoly_t A, slong len, flint_bitcnt_t bits, gr_mpoly_ctx_t ctx) - # void gr_mpoly_fit_length_reset_bits(gr_mpoly_t A, slong len, flint_bitcnt_t bits, gr_mpoly_ctx_t ctx) - # void _gr_mpoly_set_length(gr_mpoly_t A, slong newlen, gr_mpoly_ctx_t ctx) - # void _gr_mpoly_push_exp_ui(gr_mpoly_t A, const ulong * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_push_term_scalar_ui(gr_mpoly_t A, gr_srcptr c, const ulong * exp, gr_mpoly_ctx_t ctx) - # void _gr_mpoly_push_exp_fmpz(gr_mpoly_t A, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # int gr_mpoly_push_term_scalar_fmpz(gr_mpoly_t A, gr_srcptr c, const fmpz_struct * exp, gr_mpoly_ctx_t ctx) - # void gr_mpoly_sort_terms(gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # int gr_mpoly_combine_like_terms(gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # truth_t gr_mpoly_is_canonical(const gr_mpoly_t A, gr_mpoly_ctx_t ctx) - # void gr_mpoly_assert_canonical(const gr_mpoly_t A, gr_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_poly.pxd b/src/flint/flintlib/functions/gr_poly.pxd deleted file mode 100644 index bb2ae93b..00000000 --- a/src/flint/flintlib/functions/gr_poly.pxd +++ /dev/null @@ -1,366 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_poly_t, fmpq_struct, fmpq_t -from flint.flintlib.types.fmpz cimport fmpz_poly_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_mat_t, gr_poly_t, gr_ptr, gr_srcptr, gr_stream_t, gr_vec_t, truth_t - -# unknown type gr_method_poly_binary_binary_op -# unknown type gr_method_poly_binary_op -# unknown type gr_method_poly_binary_trunc_op -# unknown type gr_method_poly_gcd_op -# unknown type gr_method_poly_unary_trunc_op -# unknown type gr_method_poly_xgcd_op - - -cdef extern from "flint/gr_poly.h": - void gr_poly_init(gr_poly_t poly, gr_ctx_t ctx) - void gr_poly_init2(gr_poly_t poly, slong len, gr_ctx_t ctx) - void gr_poly_clear(gr_poly_t poly, gr_ctx_t ctx) - gr_ptr gr_poly_coeff_ptr(gr_poly_t poly, slong i, gr_ctx_t ctx) - gr_srcptr gr_poly_coeff_srcptr(const gr_poly_t poly, slong i, gr_ctx_t ctx) - gr_ptr gr_poly_entry_ptr(gr_poly_t poly, slong i, gr_ctx_t ctx) - gr_srcptr gr_poly_entry_srcptr(const gr_poly_t poly, slong i, gr_ctx_t ctx) - slong gr_poly_length(const gr_poly_t poly, gr_ctx_t ctx) - void gr_poly_swap(gr_poly_t poly1, gr_poly_t poly2, gr_ctx_t ctx) - void gr_poly_fit_length(gr_poly_t poly, slong len, gr_ctx_t ctx) - void _gr_poly_set_length(gr_poly_t poly, slong len, gr_ctx_t ctx) - void _gr_poly_normalise(gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_set(gr_poly_t res, const gr_poly_t src, gr_ctx_t ctx) - int gr_poly_get_fmpz_poly(gr_poly_t res, const fmpz_poly_t src, gr_ctx_t ctx) - int gr_poly_set_fmpq_poly(gr_poly_t res, const fmpq_poly_t src, gr_ctx_t ctx) - int gr_poly_set_gr_poly_other(gr_poly_t res, const gr_poly_t x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int _gr_poly_reverse(gr_ptr res, gr_srcptr poly, slong len, slong n, gr_ctx_t ctx) - int gr_poly_reverse(gr_poly_t res, const gr_poly_t poly, slong n, gr_ctx_t ctx) - int gr_poly_truncate(gr_poly_t res, const gr_poly_t poly, slong newlen, gr_ctx_t ctx) - int gr_poly_zero(gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_one(gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_neg_one(gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_gen(gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_write(gr_stream_t out, const gr_poly_t poly, const char * x, gr_ctx_t ctx) - int _gr_poly_write(gr_stream_t out, gr_srcptr poly, slong n, const char * x, gr_ctx_t ctx) - int _gr_poly_get_str(char ** res, const gr_poly_t f, const char * x, gr_ctx_t ctx) - int gr_poly_get_str(char ** res, const gr_poly_t f, const char * x, gr_ctx_t ctx) - int gr_poly_print(const gr_poly_t poly, gr_ctx_t ctx) - int _gr_poly_set_str(gr_ptr res, const char * s, const char * x, slong len, gr_ctx_t ctx) - int gr_poly_set_str(gr_poly_t res, const char * s, const char * x, gr_ctx_t ctx) - int gr_poly_randtest(gr_poly_t poly, flint_rand_t state, slong len, gr_ctx_t ctx) - truth_t _gr_poly_equal(gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - truth_t gr_poly_equal(const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - truth_t gr_poly_is_zero(const gr_poly_t poly, gr_ctx_t ctx) - truth_t gr_poly_is_one(const gr_poly_t poly, gr_ctx_t ctx) - truth_t gr_poly_is_gen(const gr_poly_t poly, gr_ctx_t ctx) - truth_t gr_poly_is_scalar(const gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_set_scalar(gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_set_si(gr_poly_t poly, slong c, gr_ctx_t ctx) - int gr_poly_set_ui(gr_poly_t poly, ulong c, gr_ctx_t ctx) - int gr_poly_set_fmpz(gr_poly_t poly, const fmpz_t c, gr_ctx_t ctx) - int gr_poly_set_fmpq(gr_poly_t poly, const fmpq_t c, gr_ctx_t ctx) - int gr_poly_set_coeff_scalar(gr_poly_t poly, slong n, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_set_coeff_si(gr_poly_t poly, slong n, slong c, gr_ctx_t ctx) - int gr_poly_set_coeff_ui(gr_poly_t poly, slong n, ulong c, gr_ctx_t ctx) - int gr_poly_set_coeff_fmpz(gr_poly_t poly, slong n, const fmpz_t c, gr_ctx_t ctx) - int gr_poly_set_coeff_fmpq(gr_poly_t poly, slong n, const fmpq_t c, gr_ctx_t ctx) - int gr_poly_get_coeff_scalar(gr_ptr res, const gr_poly_t poly, slong n, gr_ctx_t ctx) - int gr_poly_neg(gr_poly_t res, const gr_poly_t src, gr_ctx_t ctx) - int _gr_poly_add(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_add(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_sub(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_sub(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_mul(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_mul(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_mullow_generic(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, slong len, gr_ctx_t ctx) - int _gr_poly_mullow(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, slong len, gr_ctx_t ctx) - int gr_poly_mullow(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, slong len, gr_ctx_t ctx) - int _gr_poly_mul_karatsuba(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_mul_karatsuba(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_mul_toom33(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx); - int gr_poly_mul_toom33(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx); - int gr_poly_add_scalar(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_add_ui(gr_poly_t res, const gr_poly_t poly, ulong c, gr_ctx_t ctx) - int gr_poly_add_si(gr_poly_t res, const gr_poly_t poly, slong c, gr_ctx_t ctx) - int gr_poly_add_fmpz(gr_poly_t res, const gr_poly_t poly, const fmpz_struct c, gr_ctx_t ctx) - int gr_poly_add_fmpq(gr_poly_t res, const gr_poly_t poly, const fmpq_struct c, gr_ctx_t ctx) - int gr_poly_sub_scalar(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_sub_ui(gr_poly_t res, const gr_poly_t poly, ulong c, gr_ctx_t ctx) - int gr_poly_sub_si(gr_poly_t res, const gr_poly_t poly, slong c, gr_ctx_t ctx) - int gr_poly_sub_fmpz(gr_poly_t res, const gr_poly_t poly, const fmpz_struct c, gr_ctx_t ctx) - int gr_poly_sub_fmpq(gr_poly_t res, const gr_poly_t poly, const fmpq_struct c, gr_ctx_t ctx) - int gr_poly_mul_scalar(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_scalar_mul(gr_poly_t res, gr_srcptr c, const gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_mul_ui(gr_poly_t res, const gr_poly_t poly, ulong c, gr_ctx_t ctx) - int gr_poly_mul_si(gr_poly_t res, const gr_poly_t poly, slong c, gr_ctx_t ctx) - int gr_poly_mul_fmpz(gr_poly_t res, const gr_poly_t poly, const fmpz_struct c, gr_ctx_t ctx) - int gr_poly_mul_fmpq(gr_poly_t res, const gr_poly_t poly, const fmpq_struct c, gr_ctx_t ctx) - int gr_poly_addmul_scalar(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_submul_scalar(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int _gr_poly_pow_series_ui_binexp(gr_ptr res, gr_srcptr f, slong flen, ulong exp, slong len, gr_ctx_t ctx) - int gr_poly_pow_series_ui_binexp(gr_poly_t res, const gr_poly_t poly, ulong exp, slong len, gr_ctx_t ctx) - int _gr_poly_pow_series_ui(gr_ptr res, gr_srcptr f, slong flen, ulong exp, slong len, gr_ctx_t ctx) - int gr_poly_pow_series_ui(gr_poly_t res, const gr_poly_t poly, ulong exp, slong len, gr_ctx_t ctx) - int _gr_poly_pow_ui_binexp(gr_ptr res, gr_srcptr f, slong flen, ulong exp, gr_ctx_t ctx) - int gr_poly_pow_ui_binexp(gr_poly_t res, const gr_poly_t poly, ulong exp, gr_ctx_t ctx) - int _gr_poly_pow_ui(gr_ptr res, gr_srcptr f, slong flen, ulong exp, gr_ctx_t ctx) - int gr_poly_pow_ui(gr_poly_t res, const gr_poly_t poly, ulong exp, gr_ctx_t ctx) - int gr_poly_pow_fmpz(gr_poly_t res, const gr_poly_t poly, const fmpz_t exp, gr_ctx_t ctx) - int _gr_poly_pow_series_fmpq_recurrence(gr_ptr h, gr_srcptr f, slong flen, const fmpq_t exp, slong len, int precomp, gr_ctx_t ctx) - int gr_poly_pow_series_fmpq_recurrence(gr_poly_t res, const gr_poly_t poly, const fmpq_t exp, slong len, gr_ctx_t ctx) - int _gr_poly_shift_left(gr_ptr res, gr_srcptr poly, slong len, slong n, gr_ctx_t ctx) - int gr_poly_shift_left(gr_poly_t res, const gr_poly_t poly, slong n, gr_ctx_t ctx) - int _gr_poly_shift_right(gr_ptr res, gr_srcptr poly, slong len, slong n, gr_ctx_t ctx) - int gr_poly_shift_right(gr_poly_t res, const gr_poly_t poly, slong n, gr_ctx_t ctx) - int gr_poly_div_scalar(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int _gr_poly_divrem_divconquer_preinv1(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_srcptr invB, slong cutoff, gr_ctx_t ctx) - int _gr_poly_divrem_divconquer_noinv(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong cutoff, gr_ctx_t ctx) - int _gr_poly_divrem_divconquer(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong cutoff, gr_ctx_t ctx) - int gr_poly_divrem_divconquer(gr_poly_t Q, gr_poly_t R, const gr_poly_t A, const gr_poly_t B, slong cutoff, gr_ctx_t ctx) - int _gr_poly_divrem_basecase_preinv1(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_srcptr invB, gr_ctx_t ctx) - int _gr_poly_divrem_basecase_noinv(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int _gr_poly_divrem_basecase(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_divrem_basecase(gr_poly_t Q, gr_poly_t R, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_divrem_newton(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_divrem_newton(gr_poly_t Q, gr_poly_t R, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_divrem(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_divrem(gr_poly_t Q, gr_poly_t R, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_div_divconquer_preinv1(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_srcptr invB, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_divconquer_noinv(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_divconquer(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong cutoff, gr_ctx_t ctx) - int gr_poly_div_divconquer(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_basecase_preinv1(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_srcptr invB, gr_ctx_t ctx) - int _gr_poly_div_basecase_noinv(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int _gr_poly_div_basecase(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_div_basecase(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_div_newton(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_div_newton(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_div(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_div(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_rem(gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_rem(gr_poly_t R, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_div_newton_n_preinv(gr_ptr Q, gr_srcptr A, slong lenA, gr_srcptr FLINT_UNUSED(B), slong lenB, gr_srcptr Binv, slong lenBinv, gr_ctx_t ctx) - int gr_poly_div_newton_n_preinv(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, const gr_poly_t Binv, gr_ctx_t ctx) - int _gr_poly_divrem_newton_n_preinv(gr_ptr Q, gr_ptr R, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_srcptr Binv, slong lenBinv, gr_ctx_t ctx) - int gr_poly_divrem_newton_n_preinv(gr_poly_t Q, gr_poly_t R, const gr_poly_t A, const gr_poly_t B, const gr_poly_t Binv, gr_ctx_t ctx) - int _gr_poly_inv_series_newton(gr_ptr res, gr_srcptr A, slong Alen, slong len, slong cutoff, gr_ctx_t ctx) - int gr_poly_inv_series_newton(gr_poly_t res, const gr_poly_t A, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_inv_series_basecase_preinv1(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr Ainv, slong len, gr_ctx_t ctx) - int _gr_poly_inv_series_basecase(gr_ptr res, gr_srcptr A, slong Alen, slong len, gr_ctx_t ctx) - int gr_poly_inv_series_basecase(gr_poly_t res, const gr_poly_t A, slong len, gr_ctx_t ctx) - int _gr_poly_inv_series(gr_ptr res, gr_srcptr A, slong Alen, slong len, gr_ctx_t ctx) - int gr_poly_inv_series(gr_poly_t res, const gr_poly_t A, slong len, gr_ctx_t ctx) - int _gr_poly_div_series_newton(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, slong cutoff, gr_ctx_t ctx) - int gr_poly_div_series_newton(gr_poly_t res, const gr_poly_t A, const gr_poly_t B, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_series_divconquer(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, slong cutoff, gr_ctx_t ctx) - int gr_poly_div_series_divconquer(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_div_series_invmul(gr_ptr res, gr_srcptr B, slong Blen, gr_srcptr A, slong Alen, slong len, gr_ctx_t ctx) - int gr_poly_div_series_invmul(gr_poly_t res, const gr_poly_t A, const gr_poly_t B, slong len, gr_ctx_t ctx) - int _gr_poly_div_series_basecase_preinv1(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, gr_srcptr Binv, slong len, gr_ctx_t ctx) - int _gr_poly_div_series_basecase_noinv(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) - int _gr_poly_div_series_basecase(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) - int gr_poly_div_series_basecase(gr_poly_t res, const gr_poly_t A, const gr_poly_t B, slong len, gr_ctx_t ctx) - int _gr_poly_div_series(gr_ptr res, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) - int gr_poly_div_series(gr_poly_t res, const gr_poly_t A, const gr_poly_t B, slong len, gr_ctx_t ctx) - int _gr_poly_divexact_basecase_bidirectional(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, gr_ctx_t ctx) - int gr_poly_divexact_basecase_bidirectional(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_divexact_bidirectional(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, gr_ctx_t ctx) - int gr_poly_divexact_bidirectional(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_divexact_basecase_noinv(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, gr_ctx_t ctx) - int _gr_poly_divexact_basecase(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, gr_ctx_t ctx) - int gr_poly_divexact_basecase(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_divexact_series_basecase_noinv(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) - int _gr_poly_divexact_series_basecase(gr_ptr Q, gr_srcptr A, slong Alen, gr_srcptr B, slong Blen, slong len, gr_ctx_t ctx) - int gr_poly_divexact_series_basecase(gr_poly_t Q, const gr_poly_t A, const gr_poly_t B, slong len, gr_ctx_t ctx) - int _gr_poly_sqrt_series_newton(gr_ptr res, gr_srcptr f, slong flen, slong len, slong cutoff, gr_ctx_t ctx) - int gr_poly_sqrt_series_newton(gr_poly_t res, const gr_poly_t f, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_sqrt_series_basecase(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_sqrt_series_basecase(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_sqrt_series_miller(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_sqrt_series_miller(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_sqrt_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_sqrt_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_rsqrt_series_newton(gr_ptr res, gr_srcptr f, slong flen, slong len, slong cutoff, gr_ctx_t ctx) - int gr_poly_rsqrt_series_newton(gr_poly_t res, const gr_poly_t f, slong len, slong cutoff, gr_ctx_t ctx) - int _gr_poly_rsqrt_series_basecase(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_rsqrt_series_basecase(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_rsqrt_series_miller(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_rsqrt_series_miller(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_rsqrt_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_rsqrt_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_evaluate_rectangular(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_poly_evaluate_rectangular(gr_ptr res, const gr_poly_t poly, gr_srcptr x, gr_ctx_t ctx) - int _gr_poly_evaluate_modular(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_poly_evaluate_modular(gr_ptr res, const gr_poly_t poly, gr_srcptr x, gr_ctx_t ctx) - int _gr_poly_evaluate_horner(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_poly_evaluate_horner(gr_ptr res, const gr_poly_t poly, gr_srcptr x, gr_ctx_t ctx) - int _gr_poly_evaluate(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr x, gr_ctx_t ctx) - int gr_poly_evaluate(gr_ptr res, const gr_poly_t poly, gr_srcptr x, gr_ctx_t ctx) - int _gr_poly_evaluate_other_horner(gr_ptr res, gr_srcptr f, slong len, const gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_poly_evaluate_other_horner(gr_ptr res, const gr_poly_t f, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int _gr_poly_evaluate_other_rectangular(gr_ptr res, gr_srcptr f, slong len, const gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_poly_evaluate_other_rectangular(gr_ptr res, const gr_poly_t f, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int _gr_poly_evaluate_other(gr_ptr res, gr_srcptr f, slong len, const gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - int gr_poly_evaluate_other(gr_ptr res, const gr_poly_t f, gr_srcptr x, gr_ctx_t x_ctx, gr_ctx_t ctx) - gr_ptr * _gr_poly_tree_alloc(slong len, gr_ctx_t ctx) - void _gr_poly_tree_free(gr_ptr * tree, slong len, gr_ctx_t ctx) - int _gr_poly_tree_build(gr_ptr * tree, gr_srcptr roots, slong len, gr_ctx_t ctx) - int _gr_poly_evaluate_vec_fast_precomp(gr_ptr vs, gr_srcptr poly, slong plen, gr_ptr * tree, slong len, gr_ctx_t ctx) - int _gr_poly_evaluate_vec_fast(gr_ptr ys, gr_srcptr poly, slong plen, gr_srcptr xs, slong n, gr_ctx_t ctx) - int gr_poly_evaluate_vec_fast(gr_vec_t ys, const gr_poly_t poly, const gr_vec_t xs, gr_ctx_t ctx) - int _gr_poly_evaluate_vec_iter(gr_ptr ys, gr_srcptr poly, slong plen, gr_srcptr xs, slong n, gr_ctx_t ctx) - int gr_poly_evaluate_vec_iter(gr_vec_t ys, const gr_poly_t poly, const gr_vec_t xs, gr_ctx_t ctx) - int _gr_poly_taylor_shift_horner(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_taylor_shift_horner(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int _gr_poly_taylor_shift_divconquer(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_taylor_shift_divconquer(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int _gr_poly_taylor_shift_convolution(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_taylor_shift_convolution(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int _gr_poly_taylor_shift(gr_ptr res, gr_srcptr poly, slong len, gr_srcptr c, gr_ctx_t ctx) - int gr_poly_taylor_shift(gr_poly_t res, const gr_poly_t poly, gr_srcptr c, gr_ctx_t ctx) - int _gr_poly_compose_horner(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_compose_horner(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_compose_divconquer(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_compose_divconquer(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_compose(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_compose(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, gr_ctx_t ctx) - int _gr_poly_compose_series_horner(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, slong n, gr_ctx_t ctx) - int gr_poly_compose_series_horner(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, slong n, gr_ctx_t ctx) - int _gr_poly_compose_series_brent_kung(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, slong n, gr_ctx_t ctx) - int gr_poly_compose_series_brent_kung(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, slong n, gr_ctx_t ctx) - int _gr_poly_compose_series_divconquer(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, slong n, gr_ctx_t ctx) - int gr_poly_compose_series_divconquer(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, slong n, gr_ctx_t ctx) - int _gr_poly_compose_series(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, slong n, gr_ctx_t ctx) - int gr_poly_compose_series(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, slong n, gr_ctx_t ctx) - int _gr_poly_revert_series_lagrange(gr_ptr res, gr_srcptr f, slong flen, slong n, gr_ctx_t ctx) - int gr_poly_revert_series_lagrange(gr_poly_t res, const gr_poly_t f, slong n, gr_ctx_t ctx) - int _gr_poly_revert_series_lagrange_fast(gr_ptr res, gr_srcptr f, slong flen, slong n, gr_ctx_t ctx) - int gr_poly_revert_series_lagrange_fast(gr_poly_t res, const gr_poly_t f, slong n, gr_ctx_t ctx) - int _gr_poly_revert_series_newton(gr_ptr res, gr_srcptr f, slong flen, slong n, gr_ctx_t ctx) - int gr_poly_revert_series_newton(gr_poly_t res, const gr_poly_t f, slong n, gr_ctx_t ctx) - int _gr_poly_revert_series(gr_ptr res, gr_srcptr f, slong flen, slong n, gr_ctx_t ctx) - int gr_poly_revert_series(gr_poly_t res, const gr_poly_t f, slong n, gr_ctx_t ctx) - int _gr_poly_derivative(gr_ptr res, gr_srcptr poly, slong len, gr_ctx_t ctx) - int gr_poly_derivative(gr_poly_t res, const gr_poly_t poly, gr_ctx_t ctx) - int _gr_poly_nth_derivative(gr_ptr res, gr_srcptr poly, ulong n, slong len, gr_ctx_t ctx) - int gr_poly_nth_derivative(gr_poly_t res, const gr_poly_t poly, ulong n, gr_ctx_t ctx) - int _gr_poly_integral(gr_ptr res, gr_srcptr poly, slong len, gr_ctx_t ctx) - int gr_poly_integral(gr_poly_t res, const gr_poly_t poly, gr_ctx_t ctx) - int _gr_poly_make_monic(gr_ptr res, gr_srcptr poly, slong len, gr_ctx_t ctx) - int gr_poly_make_monic(gr_poly_t res, const gr_poly_t src, gr_ctx_t ctx) - truth_t _gr_poly_is_monic(gr_srcptr poly, slong len, gr_ctx_t ctx) - truth_t gr_poly_is_monic(const gr_poly_t res, gr_ctx_t ctx) - int gr_poly_canonical_associate(gr_poly_t res, gr_poly_t u, const gr_poly_t src, gr_ctx_t ctx) - int _gr_poly_hgcd(gr_ptr r, slong * sgn, gr_ptr * M, slong * lenM, gr_ptr A, slong * lenA, gr_ptr B, slong * lenB, gr_srcptr a, slong lena, gr_srcptr b, slong lenb, slong cutoff, gr_ctx_t ctx) - int _gr_poly_gcd_hgcd(gr_ptr G, slong * _lenG, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong inner_cutoff, slong cutoff, gr_ctx_t ctx) - int gr_poly_gcd_hgcd(gr_poly_t G, const gr_poly_t A, const gr_poly_t B, slong inner_cutoff, slong cutoff, gr_ctx_t ctx) - int _gr_poly_gcd_euclidean(gr_ptr G, slong * lenG, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_gcd_euclidean(gr_poly_t G, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_gcd_subresultant(gr_ptr G, slong * lenG, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_gcd_subresultant(gr_poly_t G, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_gcd_generic(gr_ptr G, slong * lenG, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int _gr_poly_gcd(gr_ptr G, slong * lenG, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_gcd(gr_poly_t G, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_xgcd_euclidean(slong * lenG, gr_ptr G, gr_ptr S, gr_ptr T, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_xgcd_euclidean(gr_poly_t G, gr_poly_t S, gr_poly_t T, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_xgcd_hgcd(slong * Glen, gr_ptr G, gr_ptr S, gr_ptr T, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong hgcd_cutoff, slong cutoff, gr_ctx_t ctx) - int gr_poly_xgcd_hgcd(gr_poly_t G, gr_poly_t S, gr_poly_t T, const gr_poly_t A, const gr_poly_t B, slong hgcd_cutoff, slong cutoff, gr_ctx_t ctx) - int _gr_poly_xgcd_generic(slong * lenG, gr_ptr G, gr_ptr S, gr_ptr T, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int _gr_poly_xgcd(slong * lenG, gr_ptr G, gr_ptr S, gr_ptr T, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, gr_ctx_t ctx) - int gr_poly_xgcd(gr_poly_t G, gr_poly_t S, gr_poly_t T, const gr_poly_t A, const gr_poly_t B, gr_ctx_t ctx) - int _gr_poly_resultant_euclidean(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_resultant_euclidean(gr_ptr res, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx) - int _gr_poly_resultant_hgcd(gr_ptr res, gr_srcptr A, slong lenA, gr_srcptr B, slong lenB, slong inner_cutoff, slong cutoff, gr_ctx_t ctx) - int gr_poly_resultant_hgcd(gr_ptr res, const gr_poly_t f, const gr_poly_t g, slong inner_cutoff, slong cutoff, gr_ctx_t ctx) - int _gr_poly_resultant_sylvester(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_resultant_sylvester(gr_ptr res, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx) - int _gr_poly_resultant_small(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_resultant_small(gr_ptr res, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx) - int _gr_poly_resultant(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_ctx_t ctx) - int gr_poly_resultant(gr_ptr res, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx) - int gr_poly_factor_squarefree(gr_ptr c, gr_vec_t fac, gr_vec_t exp, const gr_poly_t poly, gr_ctx_t ctx) - int gr_poly_squarefree_part(gr_poly_t res, const gr_poly_t poly, gr_ctx_t ctx) - truth_t gr_poly_shift_equivalent(fmpz_t shift, const gr_poly_t p, const gr_poly_t q, gr_ctx_t ctx) - int gr_poly_leading_taylor_shift(gr_ptr shift, const gr_poly_t p, const gr_poly_t q, gr_ctx_t ctx) - int gr_poly_dispersion_resultant(fmpz_t disp, gr_vec_t disp_set, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx); - int gr_poly_dispersion_factor(fmpz_t disp, gr_vec_t disp_set, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx); - int gr_poly_dispersion(fmpz_t disp, gr_vec_t disp_set, const gr_poly_t f, const gr_poly_t g, gr_ctx_t ctx); - int gr_poly_dispersion_from_factors(fmpz_t disp, gr_vec_t disp_set, const gr_vec_t ffac, const gr_vec_t gfac, gr_ctx_t ctx); - int gr_poly_shiftless_decomposition_factor(gr_ptr c, gr_vec_t slfac, gr_vec_t slshifts, gr_vec_t slmult, const gr_poly_t f, gr_ctx_t ctx) - int gr_poly_shiftless_decomposition(gr_ptr c, gr_vec_t slfac, gr_vec_t slshifts, gr_vec_t slmult, const gr_poly_t f, gr_ctx_t ctx) - int _gr_poly_shiftless_decomposition_from_factors(gr_vec_t slfac, gr_vec_t slshifts, gr_vec_t slmult, const gr_vec_t fac, const gr_vec_t mult, gr_ctx_t ctx) - int gr_poly_shiftless_decomposition_from_factors(gr_vec_t slfac, gr_vec_t slshifts, gr_vec_t slmult, const gr_vec_t fac, const gr_vec_t mult, gr_ctx_t ctx) - int gr_poly_roots(gr_vec_t roots, gr_vec_t mult, const gr_poly_t poly, int flags, gr_ctx_t ctx) - int gr_poly_roots_other(gr_vec_t roots, gr_vec_t mult, const gr_poly_t poly, gr_ctx_t poly_ctx, int flags, gr_ctx_t ctx) - int _gr_poly_refine_roots_aberth(gr_ptr w, gr_srcptr f, gr_srcptr f_prime, slong deg, gr_srcptr z, int progressive, gr_ctx_t ctx) - int _gr_poly_refine_roots_wdk(gr_ptr w, gr_srcptr f, slong deg, gr_srcptr z, int progressive, gr_ctx_t ctx) - int _gr_poly_asin_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_asin_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_asinh_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_asinh_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_acos_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_acos_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_acosh_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_acosh_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_atan_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_atan_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_atanh_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_atanh_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_log_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_log_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_log1p_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_log1p_series(gr_poly_t res, const gr_poly_t f, slong len, gr_ctx_t ctx) - int _gr_poly_exp_series_basecase(gr_ptr f, gr_srcptr h, slong hlen, slong n, gr_ctx_t ctx) - int gr_poly_exp_series_basecase(gr_poly_t f, const gr_poly_t h, slong n, gr_ctx_t ctx) - int _gr_poly_exp_series_basecase_mul(gr_ptr f, gr_srcptr h, slong hlen, slong n, gr_ctx_t ctx) - int gr_poly_exp_series_basecase_mul(gr_poly_t f, const gr_poly_t h, slong n, gr_ctx_t ctx) - int _gr_poly_exp_series_newton(gr_ptr f, gr_ptr g, gr_srcptr h, slong hlen, slong n, slong cutoff, gr_ctx_t ctx) - int gr_poly_exp_series_newton(gr_poly_t f, const gr_poly_t h, slong n, slong cutoff, gr_ctx_t ctx) - int _gr_poly_exp_series_generic(gr_ptr f, gr_srcptr h, slong hlen, slong n, gr_ctx_t ctx) - int _gr_poly_exp_series(gr_ptr res, gr_srcptr f, slong flen, slong len, gr_ctx_t ctx) - int gr_poly_exp_series(gr_poly_t f, const gr_poly_t h, slong n, gr_ctx_t ctx) - int _gr_poly_sin_cos_series_basecase(gr_ptr s, gr_ptr c, gr_srcptr h, slong hlen, slong n, int times_pi, gr_ctx_t ctx) - int gr_poly_sin_cos_series_basecase(gr_poly_t s, gr_poly_t c, const gr_poly_t h, slong n, int times_pi, gr_ctx_t ctx) - int _gr_poly_sin_cos_series_tangent(gr_ptr s, gr_ptr c, gr_srcptr h, slong hlen, slong n, int times_pi, gr_ctx_t ctx) - int gr_poly_sin_cos_series_tangent(gr_poly_t s, gr_poly_t c, const gr_poly_t h, slong n, int times_pi, gr_ctx_t ctx) - int _gr_poly_tan_series_basecase(gr_ptr f, gr_srcptr h, slong hlen, slong n, gr_ctx_t ctx) - int gr_poly_tan_series_basecase(gr_poly_t f, const gr_poly_t h, slong n, gr_ctx_t ctx) - int _gr_poly_tan_series_newton(gr_ptr f, gr_srcptr h, slong hlen, slong n, slong cutoff, gr_ctx_t ctx) - int gr_poly_tan_series_newton(gr_poly_t f, const gr_poly_t h, slong n, slong cutoff, gr_ctx_t ctx) - int _gr_poly_tan_series(gr_ptr f, gr_srcptr h, slong hlen, slong n, gr_ctx_t ctx) - int gr_poly_tan_series(gr_poly_t f, const gr_poly_t h, slong n, gr_ctx_t ctx) - int _gr_poly_mulmod(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_srcptr f, slong lenf, gr_ctx_t ctx) - int gr_poly_mulmod(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t f, gr_ctx_t ctx) - int _gr_poly_mulmod_preinv(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, slong len2, gr_srcptr f, slong lenf, gr_srcptr finv, slong lenfinv, gr_ctx_t ctx) - int gr_poly_mulmod_preinv(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t f, const gr_poly_t finv, gr_ctx_t ctx) - int _gr_poly_powmod_fmpz_binexp(gr_ptr res, gr_srcptr poly, const fmpz_t e, gr_srcptr f, slong lenf, gr_ctx_t ctx) - int gr_poly_powmod_fmpz_binexp(gr_poly_t res, const gr_poly_t poly, const fmpz_t e, const gr_poly_t f, gr_ctx_t ctx) - int _gr_poly_powmod_fmpz_binexp_preinv(gr_ptr res, gr_srcptr poly, const fmpz_t e, gr_srcptr f, slong lenf, gr_srcptr finv, slong lenfinv, gr_ctx_t ctx) - int gr_poly_powmod_fmpz_binexp_preinv(gr_poly_t res, const gr_poly_t poly, const fmpz_t e, const gr_poly_t f, const gr_poly_t finv, gr_ctx_t ctx) - int _gr_poly_powmod_x_fmpz_preinv(gr_ptr res, const fmpz_t e, gr_srcptr f, slong lenf, gr_srcptr finv, slong lenfinv, gr_ctx_t ctx) - int gr_poly_powmod_x_fmpz_preinv(gr_poly_t res, const fmpz_t e, const gr_poly_t f, const gr_poly_t finv, gr_ctx_t ctx) - int _gr_poly_powmod_ui_binexp(gr_ptr res, gr_srcptr poly, ulong e, gr_srcptr f, slong lenf, gr_ctx_t ctx) - int gr_poly_powmod_ui_binexp(gr_poly_t res, const gr_poly_t poly, ulong e, const gr_poly_t f, gr_ctx_t ctx) - int _gr_poly_powmod_ui_binexp_preinv(gr_ptr res, gr_srcptr poly, ulong e, gr_srcptr f, slong lenf, gr_srcptr finv, slong lenfinv, gr_ctx_t ctx) - int gr_poly_powmod_ui_binexp_preinv(gr_poly_t res, const gr_poly_t poly, ulong e, const gr_poly_t f, const gr_poly_t finv, gr_ctx_t ctx) - int _gr_poly_powmod_fmpz_sliding_preinv(gr_ptr res, gr_srcptr poly, const fmpz_t e, ulong k, gr_srcptr f, slong lenf, gr_srcptr finv, slong lenfinv, gr_ctx_t ctx) - int gr_poly_powmod_fmpz_sliding_preinv(gr_poly_t res, const gr_poly_t poly, const fmpz_t e, ulong k, const gr_poly_t f, const gr_poly_t finv, gr_ctx_t ctx) - int _gr_poly_compose_mod_horner(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, gr_srcptr poly3, slong len3, gr_ctx_t ctx) - int gr_poly_compose_mod_horner(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t poly3, gr_ctx_t ctx) - int _gr_poly_compose_mod_brent_kung(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, gr_srcptr poly3, slong len3, gr_ctx_t ctx) - int gr_poly_compose_mod_brent_kung(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t poly3, gr_ctx_t ctx) - int _gr_poly_compose_mod(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, gr_srcptr poly3, slong len3, gr_ctx_t ctx) - int gr_poly_compose_mod(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t poly3, gr_ctx_t ctx) - int _gr_poly_compose_mod_horner_preinv(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, gr_srcptr poly3, slong len3, gr_srcptr poly3inv, slong inv3len, gr_ctx_t ctx) - int gr_poly_compose_mod_horner_preinv(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t poly3, const gr_poly_t poly3inv, gr_ctx_t ctx) - int _gr_poly_compose_mod_brent_kung_preinv(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, gr_srcptr poly3, slong len3, gr_srcptr poly3inv, slong inv3len, gr_ctx_t ctx) - int gr_poly_compose_mod_brent_kung_preinv(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t poly3, const gr_poly_t poly3inv, gr_ctx_t ctx) - int _gr_poly_compose_mod_preinv(gr_ptr res, gr_srcptr poly1, slong len1, gr_srcptr poly2, gr_srcptr poly3, slong len3, gr_srcptr poly3inv, slong inv3len, gr_ctx_t ctx) - int gr_poly_compose_mod_preinv(gr_poly_t res, const gr_poly_t poly1, const gr_poly_t poly2, const gr_poly_t poly3, const gr_poly_t poly3inv, gr_ctx_t ctx) - int _gr_poly_reduce_matrix_mod_poly(gr_mat_t A, const gr_mat_t B, const gr_poly_t f, gr_ctx_t ctx) - int _gr_poly_precompute_matrix(gr_mat_t A, gr_srcptr f, gr_srcptr g, slong leng, gr_srcptr ginv, slong lenginv, gr_ctx_t ctx) - int gr_poly_precompute_matrix(gr_mat_t A, const gr_poly_t f, const gr_poly_t g, const gr_poly_t ginv, gr_ctx_t ctx) - int _gr_poly_compose_mod_brent_kung_precomp_preinv(gr_ptr res, gr_srcptr f, slong lenf, const gr_mat_t A, gr_srcptr h, slong lenh, gr_srcptr hinv, slong lenhinv, gr_ctx_t ctx) - int gr_poly_compose_mod_brent_kung_precomp_preinv(gr_poly_t res, const gr_poly_t f, const gr_mat_t A, const gr_poly_t h, const gr_poly_t hinv, gr_ctx_t ctx) - # void _gr_poly_test_mullow(gr_method_poly_binary_trunc_op mullow_impl, gr_method_poly_binary_trunc_op mullow_ref, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void _gr_poly_test_divrem(gr_method_poly_binary_binary_op divrem_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void _gr_poly_test_div(gr_method_poly_binary_op div_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void _gr_poly_test_inv_series(gr_method_poly_unary_trunc_op inv_series_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void _gr_poly_test_div_series(gr_method_poly_binary_trunc_op div_series_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void _gr_poly_test_gcd(gr_method_poly_gcd_op gcd_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) - # void _gr_poly_test_xgcd(gr_method_poly_xgcd_op xgcd_impl, flint_rand_t state, slong iters, slong maxn, gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_special.pxd b/src/flint/flintlib/functions/gr_special.pxd deleted file mode 100644 index caa12236..00000000 --- a/src/flint/flintlib/functions/gr_special.pxd +++ /dev/null @@ -1,228 +0,0 @@ -from flint.flintlib.types.dirichlet cimport dirichlet_char_t, dirichlet_group_t -from flint.flintlib.types.flint cimport fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_ptr, gr_srcptr, gr_vec_t - - - -cdef extern from "flint/gr_special.h": - int gr_pi(gr_ptr res, gr_ctx_t ctx) - int gr_euler(gr_ptr res, gr_ctx_t ctx) - int gr_catalan(gr_ptr res, gr_ctx_t ctx) - int gr_khinchin(gr_ptr res, gr_ctx_t ctx) - int gr_glaisher(gr_ptr res, gr_ctx_t ctx) - int gr_exp(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_expm1(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_exp2(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_exp10(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_exp_pi_i(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log1p(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log2(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log10(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log_pi_i(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sin(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cos(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sin_cos(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_ctx_t ctx) - int gr_tan(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cot(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sec(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_csc(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sin_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cos_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sin_cos_pi(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_ctx_t ctx) - int gr_tan_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cot_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sec_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_csc_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sinc(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sinc_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sinh(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cosh(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sinh_cosh(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_ctx_t ctx) - int gr_tanh(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_coth(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sech(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_csch(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_asin(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acos(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_atan(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_atan2(gr_ptr res, gr_srcptr y, gr_srcptr x, gr_ctx_t ctx) - int gr_acot(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_asec(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acsc(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_asin_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acos_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_atan_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acot_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_asec_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acsc_pi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_asinh(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acosh(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_atanh(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acoth(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_asech(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_acsch(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_lambertw(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_lambertw_fmpz(gr_ptr res, gr_srcptr x, const fmpz_t k, gr_ctx_t ctx) - int gr_fac(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_fac_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_fac_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_fac_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_rfac(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_rfac_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_rfac_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_rfac_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_bin(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bin_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_bin_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_bin_vec(gr_ptr res, gr_srcptr x, slong len, gr_ctx_t ctx) - int gr_bin_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - int gr_rising(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_rising_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_falling(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_falling_ui(gr_ptr res, gr_srcptr x, ulong y, gr_ctx_t ctx) - int gr_gamma(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_gamma_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_gamma_fmpq(gr_ptr res, const fmpq_t x, gr_ctx_t ctx) - int gr_rgamma(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_lgamma(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_digamma(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_barnes_g(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log_barnes_g(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_beta(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_doublefac(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_doublefac_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_harmonic(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_harmonic_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_bernoulli_ui(gr_ptr res, ulong n, gr_ctx_t ctx) - int gr_bernoulli_fmpz(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_bernoulli_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_eulernum_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_eulernum_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_eulernum_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_fib_ui(gr_ptr res, ulong n, gr_ctx_t ctx) - int gr_fib_fmpz(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_fib_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_stirling_s1u_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_stirling_s1_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_stirling_s2_uiui(gr_ptr res, ulong x, ulong y, gr_ctx_t ctx) - int gr_stirling_s1u_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - int gr_stirling_s1_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - int gr_stirling_s2_ui_vec(gr_ptr res, ulong x, slong len, gr_ctx_t ctx) - int gr_bellnum_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_bellnum_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_bellnum_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_partitions_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_partitions_fmpz(gr_ptr res, const fmpz_t x, gr_ctx_t ctx) - int gr_partitions_vec(gr_ptr res, slong len, gr_ctx_t ctx) - int gr_erf(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_erfc(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_erfcx(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_erfi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_erfinv(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_erfcinv(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_fresnel_s(gr_ptr res, gr_srcptr x, int normalized, gr_ctx_t ctx) - int gr_fresnel_c(gr_ptr res, gr_srcptr x, int normalized, gr_ctx_t ctx) - int gr_fresnel(gr_ptr res1, gr_ptr res2, gr_srcptr x, int normalized, gr_ctx_t ctx) - int gr_gamma_upper(gr_ptr res, gr_srcptr x, gr_srcptr y, int regularized, gr_ctx_t ctx) - int gr_gamma_lower(gr_ptr res, gr_srcptr x, gr_srcptr y, int regularized, gr_ctx_t ctx) - int gr_beta_lower(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, int regularized, gr_ctx_t ctx) - int gr_exp_integral(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_exp_integral_ei(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sin_integral(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cos_integral(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_sinh_integral(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_cosh_integral(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_log_integral(gr_ptr res, gr_srcptr x, int offset, gr_ctx_t ctx) - int gr_dilog(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_chebyshev_t_fmpz(gr_ptr res, const fmpz_t n, gr_srcptr x, gr_ctx_t ctx) - int gr_chebyshev_t(gr_ptr res, gr_srcptr n, gr_srcptr x, gr_ctx_t ctx) - int gr_chebyshev_u_fmpz(gr_ptr res, const fmpz_t n, gr_srcptr x, gr_ctx_t ctx) - int gr_chebyshev_u(gr_ptr res, gr_srcptr n, gr_srcptr x, gr_ctx_t ctx) - int gr_jacobi_p(gr_ptr res, gr_srcptr n, gr_srcptr a, gr_srcptr b, gr_srcptr z, gr_ctx_t ctx) - int gr_gegenbauer_c(gr_ptr res, gr_srcptr n, gr_srcptr m, gr_srcptr z, gr_ctx_t ctx) - int gr_laguerre_l(gr_ptr res, gr_srcptr n, gr_srcptr m, gr_srcptr z, gr_ctx_t ctx) - int gr_hermite_h(gr_ptr res, gr_srcptr n, gr_srcptr z, gr_ctx_t ctx) - int gr_legendre_p(gr_ptr res, gr_srcptr n, gr_srcptr m, gr_srcptr z, int type, gr_ctx_t ctx) - int gr_legendre_q(gr_ptr res, gr_srcptr n, gr_srcptr m, gr_srcptr z, int type, gr_ctx_t ctx) - int gr_spherical_y_si(gr_ptr res, slong n, slong m, gr_srcptr theta, gr_srcptr phi, gr_ctx_t ctx) - int gr_legendre_p_root_ui(gr_ptr root, gr_ptr weight, ulong n, ulong k, gr_ctx_t ctx) - int gr_bessel_j(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bessel_y(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bessel_i(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bessel_k(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bessel_j_y(gr_ptr res1, gr_ptr res2, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bessel_i_scaled(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_bessel_k_scaled(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_airy(gr_ptr res1, gr_ptr res2, gr_ptr res3, gr_ptr res4, gr_srcptr x, gr_ctx_t ctx) - int gr_airy_ai(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_airy_bi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_airy_ai_prime(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_airy_bi_prime(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_airy_ai_zero(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_airy_bi_zero(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_airy_ai_prime_zero(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_airy_bi_prime_zero(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_coulomb(gr_ptr res1, gr_ptr res2, gr_ptr res3, gr_ptr res4, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_ctx_t ctx) - int gr_coulomb_f(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_ctx_t ctx) - int gr_coulomb_g(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_ctx_t ctx) - int gr_coulomb_hpos(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_ctx_t ctx) - int gr_coulomb_hneg(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_ctx_t ctx) - int gr_hypgeom_0f1(gr_ptr res, gr_srcptr a, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_hypgeom_1f1(gr_ptr res, gr_srcptr a, gr_srcptr b, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_hypgeom_u(gr_ptr res, gr_srcptr a, gr_srcptr b, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_hypgeom_2f1(gr_ptr res, gr_srcptr a, gr_srcptr b, gr_srcptr c, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_hypgeom_pfq(gr_ptr res, const gr_vec_t a, const gr_vec_t b, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_zeta(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_zeta_ui(gr_ptr res, ulong x, gr_ctx_t ctx) - int gr_hurwitz_zeta(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_polygamma(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_polylog(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_lerch_phi(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_ctx_t ctx) - int gr_stieltjes(gr_ptr res, const fmpz_t x, gr_srcptr y, gr_ctx_t ctx) - int gr_dirichlet_eta(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_riemann_xi(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_zeta_zero(gr_ptr res, const fmpz_t n, gr_ctx_t ctx) - int gr_zeta_zero_vec(gr_ptr res, const fmpz_t n, slong len, gr_ctx_t ctx) - int gr_zeta_nzeros(gr_ptr res, gr_srcptr t, gr_ctx_t ctx) - int gr_dirichlet_chi_fmpz(gr_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, const fmpz_t n, gr_ctx_t ctx) - int gr_dirichlet_chi_vec(gr_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, slong len, gr_ctx_t ctx) - int gr_dirichlet_l(gr_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, gr_srcptr s, gr_ctx_t ctx) - int gr_dirichlet_l_all(gr_vec_t res, const dirichlet_group_t G, gr_srcptr s, gr_ctx_t ctx) - int gr_dirichlet_hardy_theta(gr_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, gr_srcptr t, gr_ctx_t ctx) - int gr_dirichlet_hardy_z(gr_ptr res, const dirichlet_group_t G, const dirichlet_char_t chi, gr_srcptr t, gr_ctx_t ctx) - int gr_agm1(gr_ptr res, gr_srcptr x, gr_ctx_t ctx) - int gr_agm(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_ctx_t ctx) - int gr_elliptic_k(gr_ptr res, gr_srcptr m, gr_ctx_t ctx) - int gr_elliptic_e(gr_ptr res, gr_srcptr m, gr_ctx_t ctx) - int gr_elliptic_pi(gr_ptr res, gr_srcptr n, gr_srcptr m, gr_ctx_t ctx) - int gr_elliptic_f(gr_ptr res, gr_srcptr phi, gr_srcptr m, int pi, gr_ctx_t ctx) - int gr_elliptic_e_inc(gr_ptr res, gr_srcptr phi, gr_srcptr m, int pi, gr_ctx_t ctx) - int gr_elliptic_pi_inc(gr_ptr res, gr_srcptr n, gr_srcptr phi, gr_srcptr m, int pi, gr_ctx_t ctx) - int gr_carlson_rc(gr_ptr res, gr_srcptr x, gr_srcptr y, int flags, gr_ctx_t ctx) - int gr_carlson_rf(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_carlson_rd(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_carlson_rg(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, int flags, gr_ctx_t ctx) - int gr_carlson_rj(gr_ptr res, gr_srcptr x, gr_srcptr y, gr_srcptr z, gr_srcptr w, int flags, gr_ctx_t ctx) - int gr_jacobi_theta(gr_ptr res1, gr_ptr res2, gr_ptr res3, gr_ptr res4, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_jacobi_theta_1(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_jacobi_theta_2(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_jacobi_theta_3(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_jacobi_theta_4(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_dedekind_eta(gr_ptr res, gr_srcptr tau, gr_ctx_t ctx) - int gr_dedekind_eta_q(gr_ptr res, gr_srcptr tau, gr_ctx_t ctx) - int gr_modular_j(gr_ptr res, gr_srcptr tau, gr_ctx_t ctx) - int gr_modular_lambda(gr_ptr res, gr_srcptr tau, gr_ctx_t ctx) - int gr_modular_delta(gr_ptr res, gr_srcptr tau, gr_ctx_t ctx) - int gr_hilbert_class_poly(gr_ptr res, slong D, gr_srcptr x, gr_ctx_t ctx) - int gr_eisenstein_e(gr_ptr res, ulong n, gr_srcptr tau, gr_ctx_t ctx) - int gr_eisenstein_g(gr_ptr res, ulong n, gr_srcptr tau, gr_ctx_t ctx) - int gr_eisenstein_g_vec(gr_ptr res, gr_srcptr tau, slong len, gr_ctx_t ctx) - int gr_elliptic_invariants(gr_ptr res1, gr_ptr res2, gr_srcptr tau, gr_ctx_t ctx) - int gr_elliptic_roots(gr_ptr res1, gr_ptr res2, gr_ptr res3, gr_srcptr tau, gr_ctx_t ctx) - int gr_weierstrass_p(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_weierstrass_p_prime(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_weierstrass_p_inv(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_weierstrass_zeta(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) - int gr_weierstrass_sigma(gr_ptr res, gr_srcptr z, gr_srcptr tau, gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/gr_vec.pxd b/src/flint/flintlib/functions/gr_vec.pxd deleted file mode 100644 index 4132bcf8..00000000 --- a/src/flint/flintlib/functions/gr_vec.pxd +++ /dev/null @@ -1,120 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t -from flint.flintlib.types.gr cimport gr_ctx_t, gr_ptr, gr_srcptr, gr_stream_t, gr_vec_t, truth_t - - -# .. macro:: GR_VEC_ENTRY(vec, i, sz) -# .. macro:: GR_ENTRY(vec, i, size) - -cdef extern from "flint/gr_vec.h": - void gr_vec_init(gr_vec_t vec, slong len, gr_ctx_t ctx) - void gr_vec_clear(gr_vec_t vec, gr_ctx_t ctx) - gr_ptr gr_vec_entry_ptr(gr_vec_t vec, slong i, gr_ctx_t ctx) - gr_srcptr gr_vec_entry_srcptr(gr_vec_t vec, slong i, gr_ctx_t ctx) - slong gr_vec_length(const gr_vec_t vec, gr_ctx_t ctx) - void gr_vec_fit_length(gr_vec_t vec, slong len, gr_ctx_t ctx) - void gr_vec_set_length(gr_vec_t vec, slong len, gr_ctx_t ctx) - int gr_vec_set(gr_vec_t res, const gr_vec_t src, gr_ctx_t ctx) - int gr_vec_append(gr_vec_t vec, gr_srcptr x, gr_ctx_t ctx) - int _gr_vec_write(gr_stream_t out, gr_srcptr vec, slong len, gr_ctx_t ctx) - int gr_vec_write(gr_stream_t out, const gr_vec_t vec, gr_ctx_t ctx) - int gr_vec_print(const gr_vec_t vec, gr_ctx_t ctx) - void _gr_vec_init(gr_ptr vec, slong len, gr_ctx_t ctx) - void _gr_vec_clear(gr_ptr vec, slong len, gr_ctx_t ctx) - void _gr_vec_swap(gr_ptr vec1, gr_ptr vec2, slong len, gr_ctx_t ctx) - int _gr_vec_randtest(gr_ptr res, flint_rand_t state, slong len, gr_ctx_t ctx) - int _gr_vec_set(gr_ptr res, gr_srcptr src, slong len, gr_ctx_t ctx) - truth_t _gr_vec_equal(gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_vec_zero(gr_ptr vec, slong len, gr_ctx_t ctx) - truth_t _gr_vec_is_zero(gr_srcptr vec, slong len, gr_ctx_t ctx) - int _gr_vec_normalise(slong * res, gr_srcptr vec, slong len, gr_ctx_t ctx) - slong _gr_vec_normalise_weak(gr_srcptr vec, slong len, gr_ctx_t ctx) - int _gr_vec_neg(gr_ptr res, gr_srcptr src, slong len, gr_ctx_t ctx) - int _gr_vec_add(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int _gr_vec_sub(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int _gr_vec_mul(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int _gr_vec_div(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int _gr_vec_divexact(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int _gr_vec_pow(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx) - int _gr_vec_add_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_sub_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_mul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_div_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_divexact_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_pow_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_scalar_add_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_sub_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_mul_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_div_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_divexact_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_pow_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_vec_add_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int _gr_vec_sub_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int _gr_vec_mul_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int _gr_vec_div_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int _gr_vec_divexact_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int _gr_vec_pow_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx) - int _gr_other_add_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int _gr_other_sub_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int _gr_other_mul_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int _gr_other_div_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int _gr_other_divexact_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int _gr_other_pow_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx) - int _gr_vec_add_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int _gr_vec_sub_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int _gr_vec_mul_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int _gr_vec_div_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int _gr_vec_divexact_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int _gr_vec_pow_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx) - int _gr_scalar_other_add_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_other_sub_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_other_mul_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_other_div_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_other_divexact_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_scalar_other_pow_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_vec_add_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_sub_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_mul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_div_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_divexact_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_pow_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_add_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int _gr_vec_sub_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int _gr_vec_mul_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int _gr_vec_div_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int _gr_vec_divexact_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int _gr_vec_pow_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx) - int _gr_vec_add_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int _gr_vec_sub_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int _gr_vec_mul_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int _gr_vec_div_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int _gr_vec_divexact_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int _gr_vec_pow_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx) - int _gr_vec_add_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int _gr_vec_sub_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int _gr_vec_mul_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int _gr_vec_div_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int _gr_vec_divexact_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int _gr_vec_pow_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx) - int _gr_vec_addmul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_submul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx) - int _gr_vec_addmul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_submul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_mul_scalar_2exp_si(gr_ptr res, gr_srcptr vec, slong len, slong c, gr_ctx_t ctx) - int _gr_vec_sum(gr_ptr res, gr_srcptr vec, slong len, gr_ctx_t ctx) - int _gr_vec_product(gr_ptr res, gr_srcptr vec, slong len, gr_ctx_t ctx) - int _gr_vec_dot(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx) - int _gr_vec_dot_si(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const slong * vec2, slong len, gr_ctx_t ctx) - int _gr_vec_dot_ui(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const ulong * vec2, slong len, gr_ctx_t ctx) - int _gr_vec_dot_fmpz(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const fmpz_struct * vec2, slong len, gr_ctx_t ctx) - int _gr_vec_dot_rev(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx) - truth_t _gr_vec_contains(gr_srcptr vec, slong len, gr_srcptr x, gr_ctx_t ctx) - truth_t gr_vec_contains(const gr_vec_t vec, gr_srcptr x, gr_ctx_t ctx); - int _gr_vec_sort(gr_ptr vec, slong len, gr_ctx_t ctx) - int gr_vec_sort(gr_vec_t dest, const gr_vec_t src, gr_ctx_t ctx) - void _gr_vec_permute(gr_ptr vec, slong * perm, slong len, gr_ctx_t ctx) - int gr_vec_permute(gr_vec_t dest, gr_vec_t src, slong * perm, gr_ctx_t ctx) - void _gr_vec_shuffle(gr_ptr vec, flint_rand_t state, slong len, gr_ctx_t ctx) - int _gr_vec_step(gr_ptr vec, gr_srcptr start, gr_srcptr step, slong len, gr_ctx_t ctx) - int _gr_vec_reciprocals(gr_ptr res, slong len, gr_ctx_t ctx) - int _gr_vec_set_powers(gr_ptr res, gr_srcptr x, slong len, gr_ctx_t ctx) diff --git a/src/flint/flintlib/functions/mag.pxd b/src/flint/flintlib/functions/mag.pxd deleted file mode 100644 index 66a8a5c4..00000000 --- a/src/flint/flintlib/functions/mag.pxd +++ /dev/null @@ -1,120 +0,0 @@ -from flint.flintlib.types.arb cimport mag_ptr, mag_t -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong -from flint.flintlib.types.fmpq cimport fmpq_t - -# unknown type FILE - - -cdef extern from "flint/mag.h": - void mag_init(mag_t x) - void mag_clear(mag_t x) - void mag_swap(mag_t x, mag_t y) - mag_ptr _mag_vec_init(slong n) - void _mag_vec_clear(mag_ptr v, slong n) - slong mag_allocated_bytes(const mag_t x) - void mag_zero(mag_t res) - void mag_one(mag_t res) - void mag_inf(mag_t res) - int mag_is_special(const mag_t x) - int mag_is_zero(const mag_t x) - int mag_is_inf(const mag_t x) - int mag_is_finite(const mag_t x) - void mag_init_set(mag_t res, const mag_t x) - void mag_set(mag_t res, const mag_t x) - void mag_set_d(mag_t res, double x) - void mag_set_ui(mag_t res, ulong x) - void mag_set_fmpz(mag_t res, const fmpz_t x) - void mag_set_d_lower(mag_t res, double x) - void mag_set_ui_lower(mag_t res, ulong x) - void mag_set_fmpz_lower(mag_t res, const fmpz_t x) - void mag_set_d_2exp_fmpz(mag_t res, double x, const fmpz_t y) - void mag_set_fmpz_2exp_fmpz(mag_t res, const fmpz_t x, const fmpz_t y) - void mag_set_ui_2exp_si(mag_t res, ulong x, slong y) - void mag_set_d_2exp_fmpz_lower(mag_t res, double x, const fmpz_t y) - void mag_set_fmpz_2exp_fmpz_lower(mag_t res, const fmpz_t x, const fmpz_t y) - double mag_get_d(const mag_t x) - double mag_get_d_log2_approx(const mag_t x) - void mag_get_fmpq(fmpq_t res, const mag_t x) - void mag_get_fmpz(fmpz_t res, const mag_t x) - void mag_get_fmpz_lower(fmpz_t res, const mag_t x) - int mag_equal(const mag_t x, const mag_t y) - int mag_cmp(const mag_t x, const mag_t y) - int mag_cmp_2exp_si(const mag_t x, slong y) - void mag_min(mag_t res, const mag_t x, const mag_t y) - void mag_max(mag_t res, const mag_t x, const mag_t y) - void mag_print(const mag_t x) - # void mag_fprint(FILE * file, const mag_t x) - char * mag_dump_str(const mag_t x) - int mag_load_str(mag_t x, const char * str) - # int mag_dump_file(FILE * stream, const mag_t x) - # int mag_load_file(mag_t x, FILE * stream) - void mag_randtest(mag_t res, flint_rand_t state, slong expbits) - void mag_randtest_special(mag_t res, flint_rand_t state, slong expbits) - void mag_add(mag_t res, const mag_t x, const mag_t y) - void mag_add_ui(mag_t res, const mag_t x, ulong y) - void mag_add_lower(mag_t res, const mag_t x, const mag_t y) - void mag_add_ui_lower(mag_t res, const mag_t x, ulong y) - void mag_add_2exp_fmpz(mag_t res, const mag_t x, const fmpz_t e) - void mag_add_ui_2exp_si(mag_t res, const mag_t x, ulong y, slong e) - void mag_sub(mag_t res, const mag_t x, const mag_t y) - void mag_sub_lower(mag_t res, const mag_t x, const mag_t y) - void mag_mul_2exp_si(mag_t res, const mag_t x, slong y) - void mag_mul_2exp_fmpz(mag_t res, const mag_t x, const fmpz_t y) - void mag_mul(mag_t res, const mag_t x, const mag_t y) - void mag_mul_ui(mag_t res, const mag_t x, ulong y) - void mag_mul_fmpz(mag_t res, const mag_t x, const fmpz_t y) - void mag_mul_lower(mag_t res, const mag_t x, const mag_t y) - void mag_mul_ui_lower(mag_t res, const mag_t x, ulong y) - void mag_mul_fmpz_lower(mag_t res, const mag_t x, const fmpz_t y) - void mag_addmul(mag_t z, const mag_t x, const mag_t y) - void mag_div(mag_t res, const mag_t x, const mag_t y) - void mag_div_ui(mag_t res, const mag_t x, ulong y) - void mag_div_fmpz(mag_t res, const mag_t x, const fmpz_t y) - void mag_div_lower(mag_t res, const mag_t x, const mag_t y) - void mag_inv(mag_t res, const mag_t x) - void mag_inv_lower(mag_t res, const mag_t x) - void mag_fast_init_set(mag_t x, const mag_t y) - void mag_fast_zero(mag_t res) - int mag_fast_is_zero(const mag_t x) - void mag_fast_mul(mag_t res, const mag_t x, const mag_t y) - void mag_fast_addmul(mag_t z, const mag_t x, const mag_t y) - void mag_fast_add_2exp_si(mag_t res, const mag_t x, slong e) - void mag_fast_mul_2exp_si(mag_t res, const mag_t x, slong e) - void mag_pow_ui(mag_t res, const mag_t x, ulong e) - void mag_pow_fmpz(mag_t res, const mag_t x, const fmpz_t e) - void mag_pow_ui_lower(mag_t res, const mag_t x, ulong e) - void mag_pow_fmpz_lower(mag_t res, const mag_t x, const fmpz_t e) - void mag_sqrt(mag_t res, const mag_t x) - void mag_sqrt_lower(mag_t res, const mag_t x) - void mag_rsqrt(mag_t res, const mag_t x) - void mag_rsqrt_lower(mag_t res, const mag_t x) - void mag_hypot(mag_t res, const mag_t x, const mag_t y) - void mag_root(mag_t res, const mag_t x, ulong n) - void mag_log(mag_t res, const mag_t x) - void mag_log_lower(mag_t res, const mag_t x) - void mag_neg_log(mag_t res, const mag_t x) - void mag_neg_log_lower(mag_t res, const mag_t x) - void mag_log_ui(mag_t res, ulong n) - void mag_log1p(mag_t res, const mag_t x) - void mag_exp(mag_t res, const mag_t x) - void mag_exp_lower(mag_t res, const mag_t x) - void mag_expinv(mag_t res, const mag_t x) - void mag_expinv_lower(mag_t res, const mag_t x) - void mag_expm1(mag_t res, const mag_t x) - void mag_exp_tail(mag_t res, const mag_t x, ulong N) - void mag_binpow_uiui(mag_t res, ulong m, ulong n) - void mag_geom_series(mag_t res, const mag_t x, ulong N) - void mag_const_pi(mag_t res) - void mag_const_pi_lower(mag_t res) - void mag_atan(mag_t res, const mag_t x) - void mag_atan_lower(mag_t res, const mag_t x) - void mag_cosh(mag_t res, const mag_t x) - void mag_cosh_lower(mag_t res, const mag_t x) - void mag_sinh(mag_t res, const mag_t x) - void mag_sinh_lower(mag_t res, const mag_t x) - void mag_fac_ui(mag_t res, ulong n) - void mag_rfac_ui(mag_t res, ulong n) - void mag_bin_uiui(mag_t res, ulong n, ulong k) - void mag_bernoulli_div_fac_ui(mag_t res, ulong n) - void mag_polylog_tail(mag_t res, const mag_t z, slong s, ulong d, ulong N) - void mag_hurwitz_zeta_uiui(mag_t res, ulong s, ulong a) diff --git a/src/flint/flintlib/functions/mpoly.pxd b/src/flint/flintlib/functions/mpoly.pxd deleted file mode 100644 index 632453be..00000000 --- a/src/flint/flintlib/functions/mpoly.pxd +++ /dev/null @@ -1,63 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, slong, ulong -from flint.flintlib.types.mpoly cimport mpoly_ctx_t, ordering_t - -# unknown type mpoly_heap1_s -# unknown type mpoly_heap_s - - -cdef extern from "flint/mpoly.h": - void mpoly_ctx_init(mpoly_ctx_t ctx, slong nvars, const ordering_t ord) - void mpoly_ctx_clear(mpoly_ctx_t mctx) - ordering_t mpoly_ordering_randtest(flint_rand_t state) - void mpoly_ctx_init_rand(mpoly_ctx_t mctx, flint_rand_t state, slong max_nvars) - int mpoly_ordering_isdeg(const mpoly_ctx_t ctx) - int mpoly_ordering_isrev(const mpoly_ctx_t cth) - void mpoly_ordering_print(ordering_t ord) - void mpoly_monomial_add(ulong * exp_ptr, const ulong * exp2, const ulong * exp3, slong N) - void mpoly_monomial_add_mp(ulong * exp_ptr, const ulong * exp2, const ulong * exp3, slong N) - void mpoly_monomial_sub(ulong * exp_ptr, const ulong * exp2, const ulong * exp3, slong N) - void mpoly_monomial_sub_mp(ulong * exp_ptr, const ulong * exp2, const ulong * exp3, slong N) - int mpoly_monomial_overflows(ulong * exp2, slong N, ulong mask) - int mpoly_monomial_overflows_mp(ulong * exp_ptr, slong N, flint_bitcnt_t bits) - int mpoly_monomial_overflows1(ulong exp, ulong mask) - void mpoly_monomial_set(ulong * exp2, const ulong * exp3, slong N) - void mpoly_monomial_swap(ulong * exp2, ulong * exp3, slong N) - void mpoly_monomial_mul_ui(ulong * exp2, const ulong * exp3, slong N, ulong c) - int mpoly_monomial_is_zero(const ulong * exp, slong N) - int mpoly_monomial_equal(const ulong * exp2, const ulong * exp3, slong N) - void mpoly_get_cmpmask(ulong * cmpmask, slong N, ulong bits, const mpoly_ctx_t mctx) - int mpoly_monomial_lt(const ulong * exp2, const ulong * exp3, slong N, const ulong * cmpmask) - int mpoly_monomial_gt(const ulong * exp2, const ulong * exp3, slong N, const ulong * cmpmask) - int mpoly_monomial_cmp(const ulong * exp2, const ulong * exp3, slong N, const ulong * cmpmask) - int mpoly_monomial_divides(ulong * exp_ptr, const ulong * exp2, const ulong * exp3, slong N, ulong mask) - int mpoly_monomial_divides_mp(ulong * exp_ptr, const ulong * exp2, const ulong * exp3, slong N, flint_bitcnt_t bits) - int mpoly_monomial_divides1(ulong * exp_ptr, const ulong exp2, const ulong exp3, ulong mask) - int mpoly_monomial_divides_tight(slong e1, slong e2, slong * prods, slong num) - flint_bitcnt_t mpoly_exp_bits_required_ui(const ulong * user_exp, const mpoly_ctx_t mctx) - flint_bitcnt_t mpoly_exp_bits_required_ffmpz(const fmpz_struct * user_exp, const mpoly_ctx_t mctx) - flint_bitcnt_t mpoly_exp_bits_required_pfmpz(fmpz_struct * const * user_exp, const mpoly_ctx_t mctx) - void mpoly_max_fields_ui_sp(ulong * max_fields, const ulong * poly_exps, slong len, ulong bits, const mpoly_ctx_t mctx) - void mpoly_max_fields_fmpz(fmpz_struct * max_fields, const ulong * poly_exps, slong len, ulong bits, const mpoly_ctx_t mctx) - void mpoly_max_degrees_tight(slong * max_exp, ulong * exps, slong len, slong * prods, slong num) - int mpoly_monomial_exists(slong * index, const ulong * poly_exps, const ulong * exp, slong len, slong N, const ulong * cmpmask) - void mpoly_search_monomials(slong ** e_ind, ulong * e, slong * e_score, slong * t1, slong * t2, slong * t3, slong lower, slong upper, const ulong * a, slong a_len, const ulong * b, slong b_len, slong N, const ulong * cmpmask) - int mpoly_term_exp_fits_ui(ulong * exps, ulong bits, slong n, const mpoly_ctx_t mctx) - int mpoly_term_exp_fits_si(ulong * exps, ulong bits, slong n, const mpoly_ctx_t mctx) - void mpoly_get_monomial_ui(ulong * exps, const ulong * poly_exps, ulong bits, const mpoly_ctx_t mctx) - void mpoly_get_monomial_ffmpz(fmpz_struct * exps, const ulong * poly_exps, flint_bitcnt_t bits, const mpoly_ctx_t mctx) - void mpoly_get_monomial_pfmpz(fmpz_struct ** exps, const ulong * poly_exps, flint_bitcnt_t bits, const mpoly_ctx_t mctx) - void mpoly_set_monomial_ui(ulong * exp1, const ulong * exp2, ulong bits, const mpoly_ctx_t mctx) - void mpoly_set_monomial_ffmpz(ulong * exp1, const fmpz_struct * exp2, flint_bitcnt_t bits, const mpoly_ctx_t mctx) - void mpoly_set_monomial_pfmpz(ulong * exp1, fmpz_struct * const * exp2, flint_bitcnt_t bits, const mpoly_ctx_t mctx) - void mpoly_pack_vec_ui(ulong * exp1, const ulong * exp2, ulong bits, slong nfields, slong len) - void mpoly_pack_vec_fmpz(ulong * exp1, const fmpz_struct * exp2, flint_bitcnt_t bits, slong nfields, slong len) - void mpoly_unpack_vec_ui(ulong * exp1, const ulong * exp2, ulong bits, slong nfields, slong len) - void mpoly_unpack_vec_fmpz(fmpz_struct * exp1, const ulong * exp2, flint_bitcnt_t bits, slong nfields, slong len) - int mpoly_repack_monomials(ulong * exps1, ulong bits1, const ulong * exps2, ulong bits2, slong len, const mpoly_ctx_t mctx) - void mpoly_pack_monomials_tight(ulong * exp1, const ulong * exp2, slong len, const slong * mults, slong num, slong bits) - void mpoly_unpack_monomials_tight(ulong * e1, ulong * e2, slong len, slong * mults, slong num, slong bits) - void mpoly_main_variable_terms1(slong * i1, slong * n1, const ulong * exp1, slong l1, slong len1, slong k, slong num, slong bits) - # int _mpoly_heap_insert(mpoly_heap_s * heap, ulong * exp, void * x, slong * next_loc, slong * heap_len, slong N, const ulong * cmpmask) - # void _mpoly_heap_insert1(mpoly_heap1_s * heap, ulong exp, void * x, slong * next_loc, slong * heap_len, ulong maskhi) - # void * _mpoly_heap_pop(mpoly_heap_s * heap, slong * heap_len, slong N, const ulong * cmpmask) - # void * _mpoly_heap_pop1(mpoly_heap1_s * heap, slong * heap_len, ulong maskhi) diff --git a/src/flint/flintlib/functions/nmod.pxd b/src/flint/flintlib/functions/nmod.pxd deleted file mode 100644 index 895507be..00000000 --- a/src/flint/flintlib/functions/nmod.pxd +++ /dev/null @@ -1,33 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_t, nmod_t, ulong - -# unknown type nmod_discrete_log_pohlig_hellman_t - -# .. macro:: NMOD_BITS(mod) -# .. macro:: NMOD_CAN_USE_SHOUP(mod) -# .. macro:: NMOD_RED2(r, a_hi, a_lo, mod) -# .. macro:: NMOD_RED(r, a, mod) -# .. macro:: NMOD2_RED2(r, a_hi, a_lo, mod) -# .. macro:: NMOD_RED3(r, a_hi, a_me, a_lo, mod) -# .. macro:: NMOD_MUL_PRENORM(res, a, b, mod) -# .. macro:: NMOD_MUL_FULLWORD(res, a, b, mod) -# .. macro:: NMOD_ADDMUL(r, a, b, mod) - -cdef extern from "flint/nmod.h": - void nmod_init(nmod_t * mod, ulong n) - ulong _nmod_add(ulong a, ulong b, nmod_t mod) - ulong nmod_add(ulong a, ulong b, nmod_t mod) - ulong _nmod_sub(ulong a, ulong b, nmod_t mod) - ulong nmod_sub(ulong a, ulong b, nmod_t mod) - ulong nmod_neg(ulong a, nmod_t mod) - ulong nmod_mul(ulong a, ulong b, nmod_t mod) - ulong _nmod_mul_fullword(ulong a, ulong b, nmod_t mod) - ulong nmod_inv(ulong a, nmod_t mod) - ulong nmod_div(ulong a, ulong b, nmod_t mod) - int nmod_divides(ulong * a, ulong b, ulong c, nmod_t mod) - ulong nmod_pow_ui(ulong a, ulong e, nmod_t mod) - ulong nmod_pow_fmpz(ulong a, const fmpz_t e, nmod_t mod) - # void nmod_discrete_log_pohlig_hellman_init(nmod_discrete_log_pohlig_hellman_t L) - # void nmod_discrete_log_pohlig_hellman_clear(nmod_discrete_log_pohlig_hellman_t L) - # double nmod_discrete_log_pohlig_hellman_precompute_prime(nmod_discrete_log_pohlig_hellman_t L, ulong p) - # ulong nmod_discrete_log_pohlig_hellman_primitive_root(const nmod_discrete_log_pohlig_hellman_t L) - # ulong nmod_discrete_log_pohlig_hellman_run(const nmod_discrete_log_pohlig_hellman_t L, ulong y) diff --git a/src/flint/flintlib/functions/nmod_mat.pxd b/src/flint/flintlib/functions/nmod_mat.pxd deleted file mode 100644 index 0365130c..00000000 --- a/src/flint/flintlib/functions/nmod_mat.pxd +++ /dev/null @@ -1,97 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.nmod cimport nmod_mat_t, nmod_poly_t - -# unknown type FILE -# unknown type thread_pool_handle - -# .. macro:: nmod_mat_entry(mat, i, j) - -cdef extern from "flint/nmod_mat.h": - void nmod_mat_init(nmod_mat_t mat, slong rows, slong cols, ulong n) - void nmod_mat_init_set(nmod_mat_t mat, const nmod_mat_t src) - void nmod_mat_clear(nmod_mat_t mat) - void nmod_mat_set(nmod_mat_t mat, const nmod_mat_t src) - void nmod_mat_swap(nmod_mat_t mat1, nmod_mat_t mat2) - void nmod_mat_swap_entrywise(nmod_mat_t mat1, nmod_mat_t mat2) - void nmod_mat_set_mod(nmod_mat_t mat, ulong n); - ulong nmod_mat_get_entry(const nmod_mat_t mat, slong i, slong j) - ulong * nmod_mat_entry_ptr(const nmod_mat_t mat, slong i, slong j) - void nmod_mat_set_entry(nmod_mat_t mat, slong i, slong j, ulong x) - slong nmod_mat_nrows(const nmod_mat_t mat) - slong nmod_mat_ncols(const nmod_mat_t mat) - void nmod_mat_zero(nmod_mat_t mat) - int nmod_mat_is_zero(const nmod_mat_t mat) - void nmod_mat_window_init(nmod_mat_t window, const nmod_mat_t mat, slong r1, slong c1, slong r2, slong c2) - void nmod_mat_window_clear(nmod_mat_t window) - void nmod_mat_concat_vertical(nmod_mat_t res, const nmod_mat_t mat1, const nmod_mat_t mat2) - void nmod_mat_concat_horizontal(nmod_mat_t res, const nmod_mat_t mat1, const nmod_mat_t mat2) - void nmod_mat_print_pretty(const nmod_mat_t mat) - # int nmod_mat_fprint_pretty(FILE * file, const nmod_mat_t mat) - int nmod_mat_print(const nmod_mat_t mat) - # int nmod_mat_fprint(FILE * f, const nmod_mat_t mat) - void nmod_mat_randtest(nmod_mat_t mat, flint_rand_t state) - void nmod_mat_randfull(nmod_mat_t mat, flint_rand_t state) - int nmod_mat_randpermdiag(nmod_mat_t mat, flint_rand_t state, nn_srcptr diag, slong n) - void nmod_mat_randrank(nmod_mat_t mat, flint_rand_t state, slong rank) - void nmod_mat_randops(nmod_mat_t mat, flint_rand_t state, slong count) - void nmod_mat_randtril(nmod_mat_t mat, flint_rand_t state, int unit) - void nmod_mat_randtriu(nmod_mat_t mat, flint_rand_t state, int unit) - int nmod_mat_equal(const nmod_mat_t mat1, const nmod_mat_t mat2) - int nmod_mat_is_zero_row(const nmod_mat_t mat, slong i) - void nmod_mat_transpose(nmod_mat_t B, const nmod_mat_t A) - void nmod_mat_swap_rows(nmod_mat_t mat, slong * perm, slong r, slong s) - void nmod_mat_swap_cols(nmod_mat_t mat, slong * perm, slong r, slong s) - void nmod_mat_invert_rows(nmod_mat_t mat, slong * perm) - void nmod_mat_invert_cols(nmod_mat_t mat, slong * perm) - void nmod_mat_permute_rows(nmod_mat_t mat, const slong * perm_act, slong * perm_store) - void nmod_mat_add(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_sub(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_neg(nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_scalar_mul(nmod_mat_t B, const nmod_mat_t A, ulong c) - void nmod_mat_scalar_addmul_ui(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B, const ulong c) - void nmod_mat_scalar_mul_fmpz(nmod_mat_t B, const nmod_mat_t A, const fmpz_t c) - void nmod_mat_mul(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void _nmod_mat_mul_classical_op(nmod_mat_t D, const nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B, int op) - void nmod_mat_mul_classical(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - # void _nmod_mat_mul_classical_threaded_pool_op(nmod_mat_t D, const nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B, int op, thread_pool_handle * threads, slong num_threads) - void _nmod_mat_mul_classical_threaded_op(nmod_mat_t D, const nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B, int op) - void nmod_mat_mul_classical_threaded(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_mul_strassen(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - int nmod_mat_mul_blas(nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_addmul(nmod_mat_t D, const nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_submul(nmod_mat_t D, const nmod_mat_t C, const nmod_mat_t A, const nmod_mat_t B) - void nmod_mat_mul_nmod_vec(ulong * c, const nmod_mat_t A, const ulong * b, slong blen) - void nmod_mat_mul_nmod_vec_ptr(ulong * const * c, const nmod_mat_t A, const ulong * const * b, slong blen) - void nmod_mat_nmod_vec_mul(ulong * c, const ulong * a, slong alen, const nmod_mat_t B) - void nmod_mat_nmod_vec_mul_ptr(ulong * const * c, const ulong * const * a, slong alen, const nmod_mat_t B) - void _nmod_mat_pow(nmod_mat_t dest, const nmod_mat_t mat, ulong pow) - void nmod_mat_pow(nmod_mat_t dest, const nmod_mat_t mat, ulong pow) - ulong nmod_mat_trace(const nmod_mat_t mat) - ulong nmod_mat_det_howell(const nmod_mat_t A) - ulong nmod_mat_det(const nmod_mat_t A) - slong nmod_mat_rank(const nmod_mat_t A) - int nmod_mat_inv(nmod_mat_t B, const nmod_mat_t A) - void nmod_mat_solve_tril(nmod_mat_t X, const nmod_mat_t L, const nmod_mat_t B, int unit) - void nmod_mat_solve_tril_classical(nmod_mat_t X, const nmod_mat_t L, const nmod_mat_t B, int unit) - void nmod_mat_solve_tril_recursive(nmod_mat_t X, const nmod_mat_t L, const nmod_mat_t B, int unit) - void nmod_mat_solve_triu(nmod_mat_t X, const nmod_mat_t U, const nmod_mat_t B, int unit) - void nmod_mat_solve_triu_classical(nmod_mat_t X, const nmod_mat_t U, const nmod_mat_t B, int unit) - void nmod_mat_solve_triu_recursive(nmod_mat_t X, const nmod_mat_t U, const nmod_mat_t B, int unit) - int nmod_mat_solve(nmod_mat_t X, const nmod_mat_t A, const nmod_mat_t B) - int nmod_mat_can_solve_inner(slong * rank, slong * perm, slong * pivots, nmod_mat_t X, const nmod_mat_t A, const nmod_mat_t B) - int nmod_mat_can_solve(nmod_mat_t X, const nmod_mat_t A, const nmod_mat_t B) - int nmod_mat_solve_vec(nn_ptr x, const nmod_mat_t A, nn_srcptr b) - slong nmod_mat_lu(slong * P, nmod_mat_t A, int rank_check) - slong nmod_mat_lu_classical(slong * P, nmod_mat_t A, int rank_check) - slong nmod_mat_lu_classical_delayed(slong * P, nmod_mat_t A, int rank_check) - slong nmod_mat_lu_recursive(slong * P, nmod_mat_t A, int rank_check) - slong nmod_mat_rref(nmod_mat_t A) - slong nmod_mat_reduce_row(nmod_mat_t A, slong * P, slong * L, slong n) - slong nmod_mat_nullspace(nmod_mat_t X, const nmod_mat_t A) - void nmod_mat_similarity(nmod_mat_t M, slong r, ulong d) - void nmod_mat_charpoly_berkowitz(nmod_poly_t p, const nmod_mat_t M) - void nmod_mat_charpoly_danilevsky(nmod_poly_t p, const nmod_mat_t M) - void nmod_mat_charpoly(nmod_poly_t p, const nmod_mat_t M) - void nmod_mat_minpoly(nmod_poly_t p, const nmod_mat_t M) - void nmod_mat_strong_echelon_form(nmod_mat_t A) - slong nmod_mat_howell_form(nmod_mat_t A) diff --git a/src/flint/flintlib/functions/nmod_mpoly.pxd b/src/flint/flintlib/functions/nmod_mpoly.pxd deleted file mode 100644 index 973a1cfe..00000000 --- a/src/flint/flintlib/functions/nmod_mpoly.pxd +++ /dev/null @@ -1,135 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_struct, fmpz_t, slong, ulong -from flint.flintlib.types.mpoly cimport ordering_t -from flint.flintlib.types.nmod cimport nmod_mpoly_ctx_t, nmod_mpoly_struct, nmod_mpoly_t, nmod_mpoly_univar_t, nmod_poly_struct, nmod_poly_t - -# unknown type FILE - - -cdef extern from "flint/nmod_mpoly.h": - void nmod_mpoly_ctx_init(nmod_mpoly_ctx_t ctx, slong nvars, const ordering_t ord, ulong n) - slong nmod_mpoly_ctx_nvars(const nmod_mpoly_ctx_t ctx) - ordering_t nmod_mpoly_ctx_ord(const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_ctx_modulus(const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_ctx_clear(nmod_mpoly_ctx_t ctx) - void nmod_mpoly_init(nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_init2(nmod_mpoly_t A, slong alloc, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_init3(nmod_mpoly_t A, slong alloc, flint_bitcnt_t bits, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_fit_length(nmod_mpoly_t A, slong len, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_realloc(nmod_mpoly_t A, slong alloc, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_clear(nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - char * nmod_mpoly_get_str_pretty(const nmod_mpoly_t A, const char ** x, const nmod_mpoly_ctx_t ctx) - # int nmod_mpoly_fprint_pretty(FILE * file, const nmod_mpoly_t A, const char ** x, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_print_pretty(const nmod_mpoly_t A, const char ** x, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_set_str_pretty(nmod_mpoly_t A, const char * str, const char ** x, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_gen(nmod_mpoly_t A, slong var, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_is_gen(const nmod_mpoly_t A, slong var, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_equal(const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_swap(nmod_mpoly_t A, nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_is_ui(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_get_ui(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_ui(nmod_mpoly_t A, ulong c, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_zero(nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_one(nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_equal_ui(const nmod_mpoly_t A, ulong c, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_is_zero(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_is_one(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_degrees_fit_si(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_degrees_fmpz(fmpz_struct ** degs, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_degrees_si(slong * degs, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_degree_fmpz(fmpz_t deg, const nmod_mpoly_t A, slong var, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_degree_si(const nmod_mpoly_t A, slong var, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_total_degree_fits_si(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_total_degree_fmpz(fmpz_t tdeg, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_total_degree_si(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_used_vars(int * used, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_get_coeff_ui_monomial(const nmod_mpoly_t A, const nmod_mpoly_t M, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_coeff_ui_monomial(nmod_mpoly_t A, ulong c, const nmod_mpoly_t M, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_get_coeff_ui_fmpz(const nmod_mpoly_t A, fmpz_struct * const * exp, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_get_coeff_ui_ui(const nmod_mpoly_t A, const ulong * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_coeff_ui_fmpz(nmod_mpoly_t A, ulong c, fmpz_struct * const * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_coeff_ui_ui(nmod_mpoly_t A, ulong c, const ulong * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_get_coeff_vars_ui(nmod_mpoly_t C, const nmod_mpoly_t A, const slong * vars, const ulong * exps, slong length, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_cmp(const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - ulong * nmod_mpoly_term_coeff_ref(nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_is_canonical(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_length(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_resize(nmod_mpoly_t A, slong new_length, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_get_term_coeff_ui(const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_term_coeff_ui(nmod_mpoly_t A, slong i, ulong c, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_term_exp_fits_si(const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_term_exp_fits_ui(const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_get_term_exp_fmpz(fmpz_struct ** exp, const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_get_term_exp_ui(ulong * exp, const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_get_term_exp_si(slong * exp, const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_get_term_var_exp_ui(const nmod_mpoly_t A, slong i, slong var, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_get_term_var_exp_si(const nmod_mpoly_t A, slong i, slong var, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_term_exp_fmpz(nmod_mpoly_t A, slong i, fmpz_struct * const * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_set_term_exp_ui(nmod_mpoly_t A, slong i, const ulong * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_get_term(nmod_mpoly_t M, const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_get_term_monomial(nmod_mpoly_t M, const nmod_mpoly_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_push_term_ui_fmpz(nmod_mpoly_t A, ulong c, fmpz_struct * const * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_push_term_ui_ffmpz(nmod_mpoly_t A, ulong c, const fmpz_struct * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_push_term_ui_ui(nmod_mpoly_t A, ulong c, const ulong * exp, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_sort_terms(nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_combine_like_terms(nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_reverse(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_randtest_bound(nmod_mpoly_t A, flint_rand_t state, slong length, ulong exp_bound, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_randtest_bounds(nmod_mpoly_t A, flint_rand_t state, slong length, ulong * exp_bounds, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_randtest_bits(nmod_mpoly_t A, flint_rand_t state, slong length, ulong exp_bits, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_add_ui(nmod_mpoly_t A, const nmod_mpoly_t B, ulong c, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_sub_ui(nmod_mpoly_t A, const nmod_mpoly_t B, ulong c, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_add(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_sub(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_neg(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_scalar_mul_ui(nmod_mpoly_t A, const nmod_mpoly_t B, ulong c, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_make_monic(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_derivative(nmod_mpoly_t A, const nmod_mpoly_t B, slong var, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_evaluate_all_ui(const nmod_mpoly_t A, const ulong * vals, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_evaluate_one_ui(nmod_mpoly_t A, const nmod_mpoly_t B, slong var, ulong val, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_compose_nmod_poly(nmod_poly_t A, const nmod_mpoly_t B, nmod_poly_struct * const * C, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_compose_nmod_mpoly_geobucket(nmod_mpoly_t A, const nmod_mpoly_t B, nmod_mpoly_struct * const * C, const nmod_mpoly_ctx_t ctxB, const nmod_mpoly_ctx_t ctxAC) - int nmod_mpoly_compose_nmod_mpoly_horner(nmod_mpoly_t A, const nmod_mpoly_t B, nmod_mpoly_struct * const * C, const nmod_mpoly_ctx_t ctxB, const nmod_mpoly_ctx_t ctxAC) - int nmod_mpoly_compose_nmod_mpoly(nmod_mpoly_t A, const nmod_mpoly_t B, nmod_mpoly_struct * const * C, const nmod_mpoly_ctx_t ctxB, const nmod_mpoly_ctx_t ctxAC) - void nmod_mpoly_compose_nmod_mpoly_gen(nmod_mpoly_t A, const nmod_mpoly_t B, const slong * c, const nmod_mpoly_ctx_t ctxB, const nmod_mpoly_ctx_t ctxAC) - void nmod_mpoly_mul(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_mul_johnson(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_mul_heap_threaded(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_mul_array(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_mul_array_threaded(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_mul_dense(nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_t C, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_pow_fmpz(nmod_mpoly_t A, const nmod_mpoly_t B, const fmpz_t k, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_pow_ui(nmod_mpoly_t A, const nmod_mpoly_t B, ulong k, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_divides(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_div(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_divrem(nmod_mpoly_t Q, nmod_mpoly_t R, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_divrem_ideal(nmod_mpoly_struct ** Q, nmod_mpoly_t R, const nmod_mpoly_t A, nmod_mpoly_struct * const * B, slong len, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_divides_dense(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_divides_monagan_pearce(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_divides_heap_threaded(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_term_content(nmod_mpoly_t M, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_content_vars(nmod_mpoly_t g, const nmod_mpoly_t A, slong * vars, slong vars_length, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_gcd(nmod_mpoly_t G, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_gcd_cofactors(nmod_mpoly_t G, nmod_mpoly_t Abar, nmod_mpoly_t Bbar, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_gcd_brown(nmod_mpoly_t G, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_gcd_hensel(nmod_mpoly_t G, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_gcd_zippel(nmod_mpoly_t G, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_resultant(nmod_mpoly_t R, const nmod_mpoly_t A, const nmod_mpoly_t B, slong var, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_discriminant(nmod_mpoly_t D, const nmod_mpoly_t A, slong var, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_sqrt(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_is_square(const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_quadratic_root(nmod_mpoly_t Q, const nmod_mpoly_t A, const nmod_mpoly_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_univar_init(nmod_mpoly_univar_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_univar_clear(nmod_mpoly_univar_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_univar_swap(nmod_mpoly_univar_t A, nmod_mpoly_univar_t B, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_to_univar(nmod_mpoly_univar_t A, const nmod_mpoly_t B, slong var, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_from_univar(nmod_mpoly_t A, const nmod_mpoly_univar_t B, slong var, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_univar_degree_fits_si(const nmod_mpoly_univar_t A, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_univar_length(const nmod_mpoly_univar_t A, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_univar_get_term_exp_si(nmod_mpoly_univar_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_univar_get_term_coeff(nmod_mpoly_t c, const nmod_mpoly_univar_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_univar_swap_term_coeff(nmod_mpoly_t c, nmod_mpoly_univar_t A, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_pow_rmul(nmod_mpoly_t A, const nmod_mpoly_t B, ulong k, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_div_monagan_pearce(nmod_mpoly_t polyq, const nmod_mpoly_t poly2, const nmod_mpoly_t poly3, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_divrem_monagan_pearce(nmod_mpoly_t q, nmod_mpoly_t r, const nmod_mpoly_t poly2, const nmod_mpoly_t poly3, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_divrem_ideal_monagan_pearce(nmod_mpoly_struct ** q, nmod_mpoly_t r, const nmod_mpoly_t poly2, nmod_mpoly_struct * const * poly3, slong len, const nmod_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/nmod_mpoly_factor.pxd b/src/flint/flintlib/functions/nmod_mpoly_factor.pxd deleted file mode 100644 index 01a05625..00000000 --- a/src/flint/flintlib/functions/nmod_mpoly_factor.pxd +++ /dev/null @@ -1,17 +0,0 @@ -from flint.flintlib.types.flint cimport slong, ulong -from flint.flintlib.types.nmod cimport nmod_mpoly_ctx_t, nmod_mpoly_factor_t, nmod_mpoly_t - - - -cdef extern from "flint/nmod_mpoly_factor.h": - void nmod_mpoly_factor_init(nmod_mpoly_factor_t f, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_factor_clear(nmod_mpoly_factor_t f, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_factor_swap(nmod_mpoly_factor_t f, nmod_mpoly_factor_t g, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_factor_length(const nmod_mpoly_factor_t f, const nmod_mpoly_ctx_t ctx) - ulong nmod_mpoly_factor_get_constant_ui(const nmod_mpoly_factor_t f, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_factor_get_base(nmod_mpoly_t p, const nmod_mpoly_factor_t f, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_factor_swap_base(nmod_mpoly_t p, nmod_mpoly_factor_t f, slong i, const nmod_mpoly_ctx_t ctx) - slong nmod_mpoly_factor_get_exp_si(nmod_mpoly_factor_t f, slong i, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_factor_sort(nmod_mpoly_factor_t f, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_factor_squarefree(nmod_mpoly_factor_t f, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - int nmod_mpoly_factor(nmod_mpoly_factor_t f, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) diff --git a/src/flint/flintlib/functions/nmod_poly.pxd b/src/flint/flintlib/functions/nmod_poly.pxd deleted file mode 100644 index df8e728c..00000000 --- a/src/flint/flintlib/functions/nmod_poly.pxd +++ /dev/null @@ -1,337 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, fmpz_t, nmod_t, nn_ptr, nn_srcptr, slong, ulong -from flint.flintlib.types.nmod cimport nmod_mat_t, nmod_poly_struct, nmod_poly_t - -# unknown type FILE -# unknown type nmod_berlekamp_massey_t -# unknown type nmod_poly_multi_crt_t -# unknown type thread_pool_handle - - -cdef extern from "flint/nmod_poly.h": - void nmod_poly_init(nmod_poly_t poly, ulong n) - void nmod_poly_init_preinv(nmod_poly_t poly, ulong n, ulong ninv) - void nmod_poly_init_mod(nmod_poly_t poly, const nmod_t mod) - void nmod_poly_init2(nmod_poly_t poly, ulong n, slong alloc) - void nmod_poly_init2_preinv(nmod_poly_t poly, ulong n, ulong ninv, slong alloc) - void nmod_poly_realloc(nmod_poly_t poly, slong alloc) - void nmod_poly_clear(nmod_poly_t poly) - void nmod_poly_fit_length(nmod_poly_t poly, slong alloc) - void _nmod_poly_normalise(nmod_poly_t poly) - slong nmod_poly_length(const nmod_poly_t poly) - slong nmod_poly_degree(const nmod_poly_t poly) - ulong nmod_poly_modulus(const nmod_poly_t poly) - flint_bitcnt_t nmod_poly_max_bits(const nmod_poly_t poly) - int nmod_poly_is_unit(const nmod_poly_t poly) - int nmod_poly_is_monic(const nmod_poly_t poly) - void nmod_poly_set(nmod_poly_t a, const nmod_poly_t b) - void nmod_poly_swap(nmod_poly_t poly1, nmod_poly_t poly2) - void nmod_poly_zero(nmod_poly_t res) - void nmod_poly_truncate(nmod_poly_t poly, slong len) - void nmod_poly_set_trunc(nmod_poly_t res, const nmod_poly_t poly, slong len) - void _nmod_poly_reverse(nn_ptr output, nn_srcptr input, slong len, slong m) - void nmod_poly_reverse(nmod_poly_t output, const nmod_poly_t input, slong m) - void nmod_poly_randtest(nmod_poly_t poly, flint_rand_t state, slong len) - void nmod_poly_randtest_irreducible(nmod_poly_t poly, flint_rand_t state, slong len) - void nmod_poly_randtest_monic(nmod_poly_t poly, flint_rand_t state, slong len) - void nmod_poly_randtest_monic_irreducible(nmod_poly_t poly, flint_rand_t state, slong len) - void nmod_poly_randtest_monic_primitive(nmod_poly_t poly, flint_rand_t state, slong len) - void nmod_poly_randtest_trinomial(nmod_poly_t poly, flint_rand_t state, slong len) - int nmod_poly_randtest_trinomial_irreducible(nmod_poly_t poly, flint_rand_t state, slong len, slong max_attempts) - void nmod_poly_randtest_pentomial(nmod_poly_t poly, flint_rand_t state, slong len) - int nmod_poly_randtest_pentomial_irreducible(nmod_poly_t poly, flint_rand_t state, slong len, slong max_attempts) - void nmod_poly_randtest_sparse_irreducible(nmod_poly_t poly, flint_rand_t state, slong len) - ulong nmod_poly_get_coeff_ui(const nmod_poly_t poly, slong j) - void nmod_poly_set_coeff_ui(nmod_poly_t poly, slong j, ulong c) - char * nmod_poly_get_str(const nmod_poly_t poly) - char * nmod_poly_get_str_pretty(const nmod_poly_t poly, const char * x) - int nmod_poly_set_str(nmod_poly_t poly, const char * s) - int nmod_poly_print(const nmod_poly_t a) - int nmod_poly_print_pretty(const nmod_poly_t a, const char * x) - # int nmod_poly_fread(FILE * f, nmod_poly_t poly) - # int nmod_poly_fprint(FILE * f, const nmod_poly_t poly) - # int nmod_poly_fprint_pretty(FILE * f, const nmod_poly_t poly, const char * x) - int nmod_poly_read(nmod_poly_t poly) - int nmod_poly_equal(const nmod_poly_t a, const nmod_poly_t b) - int nmod_poly_equal_nmod(const nmod_poly_t poly, ulong cst) - int nmod_poly_equal_ui(const nmod_poly_t poly, ulong cst) - int nmod_poly_equal_trunc(const nmod_poly_t poly1, const nmod_poly_t poly2, slong n) - int nmod_poly_is_zero(const nmod_poly_t poly) - int nmod_poly_is_one(const nmod_poly_t poly) - int nmod_poly_is_gen(const nmod_poly_t poly) - void _nmod_poly_shift_left(nn_ptr res, nn_srcptr poly, slong len, slong k) - void nmod_poly_shift_left(nmod_poly_t res, const nmod_poly_t poly, slong k) - void _nmod_poly_shift_right(nn_ptr res, nn_srcptr poly, slong len, slong k) - void nmod_poly_shift_right(nmod_poly_t res, const nmod_poly_t poly, slong k) - void _nmod_poly_add(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_add(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void nmod_poly_add_series(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong n) - void _nmod_poly_sub(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_sub(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void nmod_poly_sub_series(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong n) - void nmod_poly_neg(nmod_poly_t res, const nmod_poly_t poly) - void nmod_poly_scalar_mul_nmod(nmod_poly_t res, const nmod_poly_t poly, ulong c) - void nmod_poly_scalar_addmul_nmod(nmod_poly_t res, const nmod_poly_t poly, ulong c) - void _nmod_poly_make_monic(nn_ptr res, nn_srcptr poly, slong len, nmod_t mod) - void nmod_poly_make_monic(nmod_poly_t res, const nmod_poly_t poly) - void _nmod_poly_bit_pack(nn_ptr res, nn_srcptr poly, slong len, flint_bitcnt_t bits) - void _nmod_poly_bit_unpack(nn_ptr res, slong len, nn_srcptr mpn, ulong bits, nmod_t mod) - void nmod_poly_bit_pack(fmpz_t f, const nmod_poly_t poly, flint_bitcnt_t bit_size) - void nmod_poly_bit_unpack(nmod_poly_t poly, const fmpz_t f, flint_bitcnt_t bit_size) - void _nmod_poly_KS2_pack1(nn_ptr res, nn_srcptr op, slong n, slong s, ulong b, ulong k, slong r) - void _nmod_poly_KS2_pack(nn_ptr res, nn_srcptr op, slong n, slong s, ulong b, ulong k, slong r) - void _nmod_poly_KS2_unpack1(nn_ptr res, nn_srcptr op, slong n, ulong b, ulong k) - void _nmod_poly_KS2_unpack2(nn_ptr res, nn_srcptr op, slong n, ulong b, ulong k) - void _nmod_poly_KS2_unpack3(nn_ptr res, nn_srcptr op, slong n, ulong b, ulong k) - void _nmod_poly_KS2_unpack(nn_ptr res, nn_srcptr op, slong n, ulong b, ulong k) - void _nmod_poly_KS2_reduce(nn_ptr res, slong s, nn_srcptr op, slong n, ulong w, nmod_t mod) - void _nmod_poly_KS2_recover_reduce1(nn_ptr res, slong s, nn_srcptr op1, nn_srcptr op2, slong n, ulong b, nmod_t mod) - void _nmod_poly_KS2_recover_reduce2(nn_ptr res, slong s, nn_srcptr op1, nn_srcptr op2, slong n, ulong b, nmod_t mod) - void _nmod_poly_KS2_recover_reduce2b(nn_ptr res, slong s, nn_srcptr op1, nn_srcptr op2, slong n, ulong b, nmod_t mod) - void _nmod_poly_KS2_recover_reduce3(nn_ptr res, slong s, nn_srcptr op1, nn_srcptr op2, slong n, ulong b, nmod_t mod) - void _nmod_poly_KS2_recover_reduce(nn_ptr res, slong s, nn_srcptr op1, nn_srcptr op2, slong n, ulong b, nmod_t mod) - void _nmod_poly_mul_classical(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_mul_classical(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void _nmod_poly_mullow_classical(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, slong trunc, nmod_t mod) - void nmod_poly_mullow_classical(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong trunc) - void _nmod_poly_mulhigh_classical(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, slong start, nmod_t mod) - void nmod_poly_mulhigh_classical(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong start) - void _nmod_poly_mul_KS(nn_ptr out, nn_srcptr in1, slong len1, nn_srcptr in2, slong len2, flint_bitcnt_t bits, nmod_t mod) - void nmod_poly_mul_KS(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, flint_bitcnt_t bits) - void _nmod_poly_mul_KS2(nn_ptr res, nn_srcptr op1, slong n1, nn_srcptr op2, slong n2, nmod_t mod) - void nmod_poly_mul_KS2(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void _nmod_poly_mul_KS4(nn_ptr res, nn_srcptr op1, slong n1, nn_srcptr op2, slong n2, nmod_t mod) - void nmod_poly_mul_KS4(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void _nmod_poly_mullow_KS(nn_ptr out, nn_srcptr in1, slong len1, nn_srcptr in2, slong len2, flint_bitcnt_t bits, slong n, nmod_t mod) - void nmod_poly_mullow_KS(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, flint_bitcnt_t bits, slong n) - void _nmod_poly_mul(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_mul(nmod_poly_t res, const nmod_poly_t poly, const nmod_poly_t poly2) - void _nmod_poly_mullow(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, slong n, nmod_t mod) - void nmod_poly_mullow(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong trunc) - void _nmod_poly_mulhigh(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, slong n, nmod_t mod) - void nmod_poly_mulhigh(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong n) - void _nmod_poly_mulmod(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nn_srcptr f, slong lenf, nmod_t mod) - void nmod_poly_mulmod(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, const nmod_poly_t f) - void _nmod_poly_mulmod_preinv(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nn_srcptr f, slong lenf, nn_srcptr finv, slong lenfinv, nmod_t mod) - void nmod_poly_mulmod_preinv(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, const nmod_poly_t f, const nmod_poly_t finv) - void _nmod_poly_pow_binexp(nn_ptr res, nn_srcptr poly, slong len, ulong e, nmod_t mod) - void nmod_poly_pow_binexp(nmod_poly_t res, const nmod_poly_t poly, ulong e) - void _nmod_poly_pow(nn_ptr res, nn_srcptr poly, slong len, ulong e, nmod_t mod) - void nmod_poly_pow(nmod_poly_t res, const nmod_poly_t poly, ulong e) - void _nmod_poly_pow_trunc_binexp(nn_ptr res, nn_srcptr poly, ulong e, slong trunc, nmod_t mod) - void nmod_poly_pow_trunc_binexp(nmod_poly_t res, const nmod_poly_t poly, ulong e, slong trunc) - void _nmod_poly_pow_trunc(nn_ptr res, nn_srcptr poly, ulong e, slong trunc, nmod_t mod) - void nmod_poly_pow_trunc(nmod_poly_t res, const nmod_poly_t poly, ulong e, slong trunc) - void _nmod_poly_powmod_ui_binexp(nn_ptr res, nn_srcptr poly, ulong e, nn_srcptr f, slong lenf, nmod_t mod) - void nmod_poly_powmod_ui_binexp(nmod_poly_t res, const nmod_poly_t poly, ulong e, const nmod_poly_t f) - void _nmod_poly_powmod_fmpz_binexp(nn_ptr res, nn_srcptr poly, fmpz_t e, nn_srcptr f, slong lenf, nmod_t mod) - void nmod_poly_powmod_fmpz_binexp(nmod_poly_t res, const nmod_poly_t poly, fmpz_t e, const nmod_poly_t f) - void _nmod_poly_powmod_ui_binexp_preinv (nn_ptr res, nn_srcptr poly, ulong e, nn_srcptr f, slong lenf, nn_srcptr finv, slong lenfinv, nmod_t mod) - void nmod_poly_powmod_ui_binexp_preinv(nmod_poly_t res, const nmod_poly_t poly, ulong e, const nmod_poly_t f, const nmod_poly_t finv) - void _nmod_poly_powmod_fmpz_binexp_preinv (nn_ptr res, nn_srcptr poly, fmpz_t e, nn_srcptr f, slong lenf, nn_srcptr finv, slong lenfinv, nmod_t mod) - void nmod_poly_powmod_fmpz_binexp_preinv(nmod_poly_t res, const nmod_poly_t poly, fmpz_t e, const nmod_poly_t f, const nmod_poly_t finv) - void _nmod_poly_powmod_x_ui_preinv (nn_ptr res, ulong e, nn_srcptr f, slong lenf, nn_srcptr finv, slong lenfinv, nmod_t mod) - void nmod_poly_powmod_x_ui_preinv(nmod_poly_t res, ulong e, const nmod_poly_t f, const nmod_poly_t finv) - void _nmod_poly_powmod_x_fmpz_preinv (nn_ptr res, fmpz_t e, nn_srcptr f, slong lenf, nn_srcptr finv, slong lenfinv, nmod_t mod) - void nmod_poly_powmod_x_fmpz_preinv(nmod_poly_t res, fmpz_t e, const nmod_poly_t f, const nmod_poly_t finv) - void _nmod_poly_powers_mod_preinv_naive(nn_ptr * res, nn_srcptr f, slong flen, slong n, nn_srcptr g, slong glen, nn_srcptr ginv, slong ginvlen, const nmod_t mod) - void nmod_poly_powers_mod_naive(nmod_poly_struct * res, const nmod_poly_t f, slong n, const nmod_poly_t g) - # void _nmod_poly_powers_mod_preinv_threaded_pool(nn_ptr * res, nn_srcptr f, slong flen, slong n, nn_srcptr g, slong glen, nn_srcptr ginv, slong ginvlen, const nmod_t mod, thread_pool_handle * threads, slong num_threads) - void _nmod_poly_powers_mod_preinv_threaded(nn_ptr * res, nn_srcptr f, slong flen, slong n, nn_srcptr g, slong glen, nn_srcptr ginv, slong ginvlen, const nmod_t mod) - void nmod_poly_powers_mod_bsgs(nmod_poly_struct * res, const nmod_poly_t f, slong n, const nmod_poly_t g) - void _nmod_poly_divrem_basecase(nn_ptr Q, nn_ptr R, nn_srcptr A, slong A_len, nn_srcptr B, slong B_len, nmod_t mod) - void nmod_poly_divrem_basecase(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B) - void _nmod_poly_divrem(nn_ptr Q, nn_ptr R, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_divrem(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B) - void _nmod_poly_div(nn_ptr Q, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_div(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B) - void _nmod_poly_rem_q1(nn_ptr R, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void _nmod_poly_rem(nn_ptr R, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_rem(nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B) - void _nmod_poly_divexact(nn_ptr Q, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_divexact(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B) - void _nmod_poly_inv_series_basecase(nn_ptr Qinv, nn_srcptr Q, slong Qlen, slong n, nmod_t mod) - void nmod_poly_inv_series_basecase(nmod_poly_t Qinv, const nmod_poly_t Q, slong n) - void _nmod_poly_inv_series_newton(nn_ptr Qinv, nn_srcptr Q, slong Qlen, slong n, nmod_t mod) - void nmod_poly_inv_series_newton(nmod_poly_t Qinv, const nmod_poly_t Q, slong n) - void _nmod_poly_inv_series(nn_ptr Qinv, nn_srcptr Q, slong Qlen, slong n, nmod_t mod) - void nmod_poly_inv_series(nmod_poly_t Qinv, const nmod_poly_t Q, slong n) - void _nmod_poly_div_series_basecase(nn_ptr Q, nn_srcptr A, slong Alen, nn_srcptr B, slong Blen, slong n, nmod_t mod) - void nmod_poly_div_series_basecase(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B, slong n) - void _nmod_poly_div_series(nn_ptr Q, nn_srcptr A, slong Alen, nn_srcptr B, slong Blen, slong n, nmod_t mod) - void nmod_poly_div_series(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B, slong n) - void _nmod_poly_div_newton_n_preinv (nn_ptr Q, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nn_srcptr Binv, slong lenBinv, nmod_t mod) - void nmod_poly_div_newton_n_preinv (nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B, const nmod_poly_t Binv) - void _nmod_poly_divrem_newton_n_preinv (nn_ptr Q, nn_ptr R, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nn_srcptr Binv, slong lenBinv, nmod_t mod) - void nmod_poly_divrem_newton_n_preinv(nmod_poly_t Q, nmod_poly_t R, const nmod_poly_t A, const nmod_poly_t B, const nmod_poly_t Binv) - ulong _nmod_poly_div_root(nn_ptr Q, nn_srcptr A, slong len, ulong c, nmod_t mod) - ulong nmod_poly_div_root(nmod_poly_t Q, const nmod_poly_t A, ulong c) - int _nmod_poly_divides_classical(nn_ptr Q, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - int nmod_poly_divides_classical(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B) - int _nmod_poly_divides(nn_ptr Q, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - int nmod_poly_divides(nmod_poly_t Q, const nmod_poly_t A, const nmod_poly_t B) - ulong nmod_poly_remove(nmod_poly_t f, const nmod_poly_t p) - void _nmod_poly_derivative(nn_ptr x_prime, nn_srcptr x, slong len, nmod_t mod) - void nmod_poly_derivative(nmod_poly_t x_prime, const nmod_poly_t x) - void _nmod_poly_integral(nn_ptr x_int, nn_srcptr x, slong len, nmod_t mod) - void nmod_poly_integral(nmod_poly_t x_int, const nmod_poly_t x) - ulong _nmod_poly_evaluate_nmod_precomp(nn_srcptr poly, slong len, ulong c, ulong c_precomp, nmod_t mod) - ulong _nmod_poly_evaluate_nmod_precomp_lazy(nn_srcptr poly, slong len, ulong c, ulong c_precomp, nmod_t mod) - ulong _nmod_poly_evaluate_nmod(nn_srcptr poly, slong len, ulong c, nmod_t mod) - ulong nmod_poly_evaluate_nmod(const nmod_poly_t poly, ulong c) - void nmod_poly_evaluate_mat_horner(nmod_mat_t dest, const nmod_poly_t poly, const nmod_mat_t c) - void nmod_poly_evaluate_mat_paterson_stockmeyer(nmod_mat_t dest, const nmod_poly_t poly, const nmod_mat_t c) - void nmod_poly_evaluate_mat(nmod_mat_t dest, const nmod_poly_t poly, const nmod_mat_t c) - void _nmod_poly_evaluate_nmod_vec_iter(nn_ptr ys, nn_srcptr poly, slong len, nn_srcptr xs, slong n, nmod_t mod) - void nmod_poly_evaluate_nmod_vec_iter(nn_ptr ys, const nmod_poly_t poly, nn_srcptr xs, slong n) - void _nmod_poly_evaluate_nmod_vec_fast_precomp(nn_ptr vs, nn_srcptr poly, slong plen, const nn_ptr * tree, slong len, nmod_t mod) - void _nmod_poly_evaluate_nmod_vec_fast(nn_ptr ys, nn_srcptr poly, slong len, nn_srcptr xs, slong n, nmod_t mod) - void nmod_poly_evaluate_nmod_vec_fast(nn_ptr ys, const nmod_poly_t poly, nn_srcptr xs, slong n) - void _nmod_poly_evaluate_nmod_vec(nn_ptr ys, nn_srcptr poly, slong len, nn_srcptr xs, slong n, nmod_t mod) - void nmod_poly_evaluate_nmod_vec(nn_ptr ys, const nmod_poly_t poly, nn_srcptr xs, slong n) - void _nmod_poly_interpolate_nmod_vec(nn_ptr poly, nn_srcptr xs, nn_srcptr ys, slong n, nmod_t mod) - void nmod_poly_interpolate_nmod_vec(nmod_poly_t poly, nn_srcptr xs, nn_srcptr ys, slong n) - void _nmod_poly_interpolation_weights(nn_ptr w, const nn_ptr * tree, slong len, nmod_t mod) - void _nmod_poly_interpolate_nmod_vec_fast_precomp(nn_ptr poly, nn_srcptr ys, const nn_ptr * tree, nn_srcptr weights, slong len, nmod_t mod) - void _nmod_poly_interpolate_nmod_vec_fast(nn_ptr poly, nn_srcptr xs, nn_srcptr ys, slong n, nmod_t mod) - void nmod_poly_interpolate_nmod_vec_fast(nmod_poly_t poly, nn_srcptr xs, nn_srcptr ys, slong n) - void _nmod_poly_interpolate_nmod_vec_newton(nn_ptr poly, nn_srcptr xs, nn_srcptr ys, slong n, nmod_t mod) - void nmod_poly_interpolate_nmod_vec_newton(nmod_poly_t poly, nn_srcptr xs, nn_srcptr ys, slong n) - void _nmod_poly_interpolate_nmod_vec_barycentric(nn_ptr poly, nn_srcptr xs, nn_srcptr ys, slong n, nmod_t mod) - void nmod_poly_interpolate_nmod_vec_barycentric(nmod_poly_t poly, nn_srcptr xs, nn_srcptr ys, slong n) - void _nmod_poly_compose_horner(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_compose_horner(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void _nmod_poly_compose_divconquer(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_compose_divconquer(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void _nmod_poly_compose(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - void nmod_poly_compose(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2) - void _nmod_poly_taylor_shift_horner(nn_ptr poly, ulong c, slong len, nmod_t mod) - void nmod_poly_taylor_shift_horner(nmod_poly_t g, const nmod_poly_t f, ulong c) - void _nmod_poly_taylor_shift_convolution(nn_ptr poly, ulong c, slong len, nmod_t mod) - void nmod_poly_taylor_shift_convolution(nmod_poly_t g, const nmod_poly_t f, ulong c) - void _nmod_poly_taylor_shift(nn_ptr poly, ulong c, slong len, nmod_t mod) - void nmod_poly_taylor_shift(nmod_poly_t g, const nmod_poly_t f, ulong c) - void _nmod_poly_compose_mod_horner(nn_ptr res, nn_srcptr f, slong lenf, nn_srcptr g, nn_srcptr h, slong lenh, nmod_t mod) - void nmod_poly_compose_mod_horner(nmod_poly_t res, const nmod_poly_t f, const nmod_poly_t g, const nmod_poly_t h) - void _nmod_poly_compose_mod_brent_kung(nn_ptr res, nn_srcptr f, slong lenf, nn_srcptr g, nn_srcptr h, slong lenh, nmod_t mod) - void nmod_poly_compose_mod_brent_kung(nmod_poly_t res, const nmod_poly_t f, const nmod_poly_t g, const nmod_poly_t h) - void _nmod_poly_compose_mod_brent_kung_preinv(nn_ptr res, nn_srcptr f, slong lenf, nn_srcptr g, nn_srcptr h, slong lenh, nn_srcptr hinv, slong lenhinv, nmod_t mod) - void nmod_poly_compose_mod_brent_kung_preinv(nmod_poly_t res, const nmod_poly_t f, const nmod_poly_t g, const nmod_poly_t h, const nmod_poly_t hinv) - void _nmod_poly_reduce_matrix_mod_poly (nmod_mat_t A, const nmod_mat_t B, const nmod_poly_t f) - void _nmod_poly_precompute_matrix_worker (void * arg_ptr) - void _nmod_poly_precompute_matrix (nmod_mat_t A, nn_srcptr f, nn_srcptr g, slong leng, nn_srcptr ginv, slong lenginv, nmod_t mod) - void nmod_poly_precompute_matrix (nmod_mat_t A, const nmod_poly_t f, const nmod_poly_t g, const nmod_poly_t ginv) - void _nmod_poly_compose_mod_brent_kung_precomp_preinv_worker(void * arg_ptr) - void _nmod_poly_compose_mod_brent_kung_precomp_preinv(nn_ptr res, nn_srcptr f, slong lenf, const nmod_mat_t A, nn_srcptr h, slong lenh, nn_srcptr hinv, slong lenhinv, nmod_t mod) - void nmod_poly_compose_mod_brent_kung_precomp_preinv(nmod_poly_t res, const nmod_poly_t f, const nmod_mat_t A, const nmod_poly_t h, const nmod_poly_t hinv) - void _nmod_poly_compose_mod_brent_kung_vec_preinv(nmod_poly_struct * res, const nmod_poly_struct * polys, slong len1, slong l, nn_srcptr g, slong leng, nn_srcptr h, slong lenh, nn_srcptr hinv, slong lenhinv, nmod_t mod) - void nmod_poly_compose_mod_brent_kung_vec_preinv(nmod_poly_struct * res, const nmod_poly_struct * polys, slong len1, slong n, const nmod_poly_t g, const nmod_poly_t h, const nmod_poly_t hinv) - # void _nmod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool(nmod_poly_struct * res, const nmod_poly_struct * polys, slong lenpolys, slong l, nn_srcptr g, slong glen, nn_srcptr poly, slong len, nn_srcptr polyinv, slong leninv, nmod_t mod, thread_pool_handle * threads, slong num_threads) - # void nmod_poly_compose_mod_brent_kung_vec_preinv_threaded_pool(nmod_poly_struct * res, const nmod_poly_struct * polys, slong len1, slong n, const nmod_poly_t g, const nmod_poly_t poly, const nmod_poly_t polyinv, thread_pool_handle * threads, slong num_threads) - void nmod_poly_compose_mod_brent_kung_vec_preinv_threaded(nmod_poly_struct * res, const nmod_poly_struct * polys, slong len1, slong n, const nmod_poly_t g, const nmod_poly_t poly, const nmod_poly_t polyinv) - void _nmod_poly_compose_mod(nn_ptr res, nn_srcptr f, slong lenf, nn_srcptr g, nn_srcptr h, slong lenh, nmod_t mod) - void nmod_poly_compose_mod(nmod_poly_t res, const nmod_poly_t f, const nmod_poly_t g, const nmod_poly_t h) - slong _nmod_poly_gcd_euclidean(nn_ptr G, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_gcd_euclidean(nmod_poly_t G, const nmod_poly_t A, const nmod_poly_t B) - slong _nmod_poly_hgcd(nn_ptr * M, slong * lenM, nn_ptr A, slong * lenA, nn_ptr B, slong * lenB, nn_srcptr a, slong lena, nn_srcptr b, slong lenb, nmod_t mod) - slong _nmod_poly_gcd_hgcd(nn_ptr G, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_gcd_hgcd(nmod_poly_t G, const nmod_poly_t A, const nmod_poly_t B) - slong _nmod_poly_gcd(nn_ptr G, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_gcd(nmod_poly_t G, const nmod_poly_t A, const nmod_poly_t B) - slong _nmod_poly_xgcd_euclidean(nn_ptr G, nn_ptr S, nn_ptr T, nn_srcptr A, slong A_len, nn_srcptr B, slong B_len, nmod_t mod) - void nmod_poly_xgcd_euclidean(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B) - slong _nmod_poly_xgcd_hgcd(nn_ptr G, nn_ptr S, nn_ptr T, nn_srcptr A, slong A_len, nn_srcptr B, slong B_len, nmod_t mod) - void nmod_poly_xgcd_hgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B) - slong _nmod_poly_xgcd(nn_ptr G, nn_ptr S, nn_ptr T, nn_srcptr A, slong lenA, nn_srcptr B, slong lenB, nmod_t mod) - void nmod_poly_xgcd(nmod_poly_t G, nmod_poly_t S, nmod_poly_t T, const nmod_poly_t A, const nmod_poly_t B) - ulong _nmod_poly_resultant_euclidean(nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - ulong nmod_poly_resultant_euclidean(const nmod_poly_t f, const nmod_poly_t g) - ulong _nmod_poly_resultant_hgcd(nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - ulong nmod_poly_resultant_hgcd(const nmod_poly_t f, const nmod_poly_t g) - ulong _nmod_poly_resultant(nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, nmod_t mod) - ulong nmod_poly_resultant(const nmod_poly_t f, const nmod_poly_t g) - slong _nmod_poly_gcdinv(ulong * G, ulong * S, const ulong * A, slong lenA, const ulong * B, slong lenB, const nmod_t mod) - void nmod_poly_gcdinv(nmod_poly_t G, nmod_poly_t S, const nmod_poly_t A, const nmod_poly_t B) - int _nmod_poly_invmod(ulong * A, const ulong * B, slong lenB, const ulong * P, slong lenP, const nmod_t mod) - int nmod_poly_invmod(nmod_poly_t A, const nmod_poly_t B, const nmod_poly_t P) - ulong _nmod_poly_discriminant(nn_srcptr poly, slong len, nmod_t mod) - ulong nmod_poly_discriminant(const nmod_poly_t f) - void _nmod_poly_compose_series(nn_ptr res, nn_srcptr poly1, slong len1, nn_srcptr poly2, slong len2, slong n, nmod_t mod) - void nmod_poly_compose_series(nmod_poly_t res, const nmod_poly_t poly1, const nmod_poly_t poly2, slong n) - void _nmod_poly_revert_series(nn_ptr Qinv, nn_srcptr Q, slong Qlen, slong n, nmod_t mod) - void nmod_poly_revert_series(nmod_poly_t Qinv, const nmod_poly_t Q, slong n) - void _nmod_poly_invsqrt_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_invsqrt_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_sqrt_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_sqrt_series(nmod_poly_t g, const nmod_poly_t h, slong n) - int _nmod_poly_sqrt(nn_ptr s, nn_srcptr p, slong n, nmod_t mod) - int nmod_poly_sqrt(nmod_poly_t s, const nmod_poly_t p) - void _nmod_poly_power_sums_naive(nn_ptr res, nn_srcptr poly, slong len, slong n, nmod_t mod) - void nmod_poly_power_sums_naive(nmod_poly_t res, const nmod_poly_t poly, slong n) - void _nmod_poly_power_sums_schoenhage(nn_ptr res, nn_srcptr poly, slong len, slong n, nmod_t mod) - void nmod_poly_power_sums_schoenhage(nmod_poly_t res, const nmod_poly_t poly, slong n) - void _nmod_poly_power_sums(nn_ptr res, nn_srcptr poly, slong len, slong n, nmod_t mod) - void nmod_poly_power_sums(nmod_poly_t res, const nmod_poly_t poly, slong n) - void _nmod_poly_power_sums_to_poly_naive(nn_ptr res, nn_srcptr poly, slong len, nmod_t mod) - void nmod_poly_power_sums_to_poly_naive(nmod_poly_t res, const nmod_poly_t Q) - void _nmod_poly_power_sums_to_poly_schoenhage(nn_ptr res, nn_srcptr poly, slong len, nmod_t mod) - void nmod_poly_power_sums_to_poly_schoenhage(nmod_poly_t res, const nmod_poly_t Q) - void _nmod_poly_power_sums_to_poly(nn_ptr res, nn_srcptr poly, slong len, nmod_t mod) - void nmod_poly_power_sums_to_poly(nmod_poly_t res, const nmod_poly_t Q) - void _nmod_poly_log_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_log_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_exp_series(nn_ptr f, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void _nmod_poly_exp_expinv_series(nn_ptr f, nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_exp_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_atan_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_atan_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_atanh_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_atanh_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_asin_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_asin_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_asinh_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_asinh_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_sin_series(nn_ptr g, nn_srcptr h, slong n, nmod_t mod) - void nmod_poly_sin_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_cos_series(nn_ptr g, nn_srcptr h, slong n, nmod_t mod) - void nmod_poly_cos_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_tan_series(nn_ptr g, nn_srcptr h, slong hlen, slong n, nmod_t mod) - void nmod_poly_tan_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_sinh_series(nn_ptr g, nn_srcptr h, slong n, nmod_t mod) - void nmod_poly_sinh_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_cosh_series(nn_ptr g, nn_srcptr h, slong n, nmod_t mod) - void nmod_poly_cosh_series(nmod_poly_t g, const nmod_poly_t h, slong n) - void _nmod_poly_tanh_series(nn_ptr g, nn_srcptr h, slong n, nmod_t mod) - void nmod_poly_tanh_series(nmod_poly_t g, const nmod_poly_t h, slong n) - int _nmod_poly_conway(nn_ptr op, ulong prime, slong deg) - ulong _nmod_poly_conway_rand(slong * degree, flint_rand_t state, int type) - void _nmod_poly_product_roots_nmod_vec(nn_ptr poly, nn_srcptr xs, slong n, nmod_t mod) - void nmod_poly_product_roots_nmod_vec(nmod_poly_t poly, nn_srcptr xs, slong n) - int nmod_poly_find_distinct_nonzero_roots(ulong * roots, const nmod_poly_t A) - nn_ptr * _nmod_poly_tree_alloc(slong len) - void _nmod_poly_tree_free(nn_ptr * tree, slong len) - void _nmod_poly_tree_build(nn_ptr * tree, nn_srcptr roots, slong len, nmod_t mod) - void nmod_poly_inflate(nmod_poly_t result, const nmod_poly_t input, slong inflation) - void nmod_poly_deflate(nmod_poly_t result, const nmod_poly_t input, slong deflation) - slong nmod_poly_deflation(const nmod_poly_t input) - # void nmod_poly_multi_crt_init(nmod_poly_multi_crt_t CRT) - # int nmod_poly_multi_crt_precompute(nmod_poly_multi_crt_t CRT, const nmod_poly_struct * moduli, slong len) - # int nmod_poly_multi_crt_precompute_p(nmod_poly_multi_crt_t CRT, const nmod_poly_struct * const * moduli, slong len) - # void nmod_poly_multi_crt_precomp(nmod_poly_t output, const nmod_poly_multi_crt_t CRT, const nmod_poly_struct * values) - # void nmod_poly_multi_crt_precomp_p(nmod_poly_t output, const nmod_poly_multi_crt_t CRT, const nmod_poly_struct * const * values) - int nmod_poly_multi_crt(nmod_poly_t output, const nmod_poly_struct * moduli, const nmod_poly_struct * values, slong len) - # void nmod_poly_multi_crt_clear(nmod_poly_multi_crt_t CRT) - # slong _nmod_poly_multi_crt_local_size(const nmod_poly_multi_crt_t CRT) - # void _nmod_poly_multi_crt_run(nmod_poly_struct * outputs, const nmod_poly_multi_crt_t CRT, const nmod_poly_struct * inputs) - # void _nmod_poly_multi_crt_run_p(nmod_poly_struct * outputs, const nmod_poly_multi_crt_t CRT, const nmod_poly_struct * const * inputs) - # void nmod_berlekamp_massey_init(nmod_berlekamp_massey_t B, ulong p) - # void nmod_berlekamp_massey_clear(nmod_berlekamp_massey_t B) - # void nmod_berlekamp_massey_start_over(nmod_berlekamp_massey_t B) - # void nmod_berlekamp_massey_set_prime(nmod_berlekamp_massey_t B, ulong p) - # void nmod_berlekamp_massey_add_points(nmod_berlekamp_massey_t B, const ulong * a, slong count) - # void nmod_berlekamp_massey_add_zeros(nmod_berlekamp_massey_t B, slong count) - # void nmod_berlekamp_massey_add_point(nmod_berlekamp_massey_t B, ulong a) - # int nmod_berlekamp_massey_reduce(nmod_berlekamp_massey_t B) - # slong nmod_berlekamp_massey_point_count(const nmod_berlekamp_massey_t B) - # const ulong * nmod_berlekamp_massey_points(const nmod_berlekamp_massey_t B) - # const nmod_poly_struct * nmod_berlekamp_massey_V_poly(const nmod_berlekamp_massey_t B) - # const nmod_poly_struct * nmod_berlekamp_massey_R_poly(const nmod_berlekamp_massey_t B) diff --git a/src/flint/flintlib/functions/nmod_poly_factor.pxd b/src/flint/flintlib/functions/nmod_poly_factor.pxd deleted file mode 100644 index 4413eee1..00000000 --- a/src/flint/flintlib/functions/nmod_poly_factor.pxd +++ /dev/null @@ -1,33 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, nmod_t, nn_srcptr, slong, ulong -from flint.flintlib.types.nmod cimport nmod_poly_factor_t, nmod_poly_t - - - -cdef extern from "flint/nmod_poly_factor.h": - void nmod_poly_factor_init(nmod_poly_factor_t fac) - void nmod_poly_factor_clear(nmod_poly_factor_t fac) - void nmod_poly_factor_realloc(nmod_poly_factor_t fac, slong alloc) - void nmod_poly_factor_fit_length(nmod_poly_factor_t fac, slong len) - void nmod_poly_factor_set(nmod_poly_factor_t res, const nmod_poly_factor_t fac) - void nmod_poly_factor_print(const nmod_poly_factor_t fac) - void nmod_poly_factor_insert(nmod_poly_factor_t fac, const nmod_poly_t poly, slong exp) - void nmod_poly_factor_concat(nmod_poly_factor_t res, const nmod_poly_factor_t fac) - void nmod_poly_factor_pow(nmod_poly_factor_t fac, slong exp) - int nmod_poly_is_irreducible(const nmod_poly_t f) - int nmod_poly_is_irreducible_ddf(const nmod_poly_t f) - int nmod_poly_is_irreducible_rabin(const nmod_poly_t f) - int _nmod_poly_is_squarefree(nn_srcptr f, slong len, nmod_t mod) - int nmod_poly_is_squarefree(const nmod_poly_t f) - void nmod_poly_factor_squarefree(nmod_poly_factor_t res, const nmod_poly_t f) - int nmod_poly_factor_equal_deg_prob(nmod_poly_t factor, flint_rand_t state, const nmod_poly_t pol, slong d) - void nmod_poly_factor_equal_deg(nmod_poly_factor_t factors, const nmod_poly_t pol, slong d) - void nmod_poly_factor_distinct_deg(nmod_poly_factor_t res, const nmod_poly_t poly, slong * const * degs) - void nmod_poly_factor_distinct_deg_threaded(nmod_poly_factor_t res, const nmod_poly_t poly, slong * const * degs) - void nmod_poly_factor_cantor_zassenhaus(nmod_poly_factor_t res, const nmod_poly_t f) - void nmod_poly_factor_berlekamp(nmod_poly_factor_t res, const nmod_poly_t f) - void nmod_poly_factor_kaltofen_shoup(nmod_poly_factor_t res, const nmod_poly_t poly) - ulong nmod_poly_factor_with_berlekamp(nmod_poly_factor_t res, const nmod_poly_t f) - ulong nmod_poly_factor_with_cantor_zassenhaus(nmod_poly_factor_t res, const nmod_poly_t f) - ulong nmod_poly_factor_with_kaltofen_shoup(nmod_poly_factor_t res, const nmod_poly_t f) - ulong nmod_poly_factor(nmod_poly_factor_t res, const nmod_poly_t f) - void _nmod_poly_interval_poly_worker(void * arg_ptr) diff --git a/src/flint/flintlib/functions/nmod_vec.pxd b/src/flint/flintlib/functions/nmod_vec.pxd deleted file mode 100644 index e4eaa7fc..00000000 --- a/src/flint/flintlib/functions/nmod_vec.pxd +++ /dev/null @@ -1,33 +0,0 @@ -from flint.flintlib.types.flint cimport flint_bitcnt_t, flint_rand_t, nmod_t, nn_ptr, nn_srcptr, slong, ulong - -# unknown type FILE -# unknown type dot_params_t - -# .. macro:: NMOD_VEC_DOT(res, i, len, expr1, expr2, mod, params) - -cdef extern from "flint/nmod_vec.h": - nn_ptr _nmod_vec_init(slong len) - void _nmod_vec_clear(nn_ptr vec) - void _nmod_vec_randtest(nn_ptr vec, flint_rand_t state, slong len, nmod_t mod) - void _nmod_vec_set(nn_ptr res, nn_srcptr vec, slong len) - void _nmod_vec_zero(nn_ptr vec, slong len) - void _nmod_vec_swap(nn_ptr a, nn_ptr b, slong length) - void _nmod_vec_reduce(nn_ptr res, nn_srcptr vec, slong len, nmod_t mod) - flint_bitcnt_t _nmod_vec_max_bits(nn_srcptr vec, slong len) - int _nmod_vec_equal(nn_srcptr vec, nn_srcptr vec2, slong len) - void _nmod_vec_print_pretty(nn_srcptr vec, slong len, nmod_t mod) - # int _nmod_vec_fprint_pretty(FILE * file, nn_srcptr vec, slong len, nmod_t mod) - int _nmod_vec_print(nn_srcptr vec, slong len, nmod_t mod) - # int _nmod_vec_fprint(FILE * f, nn_srcptr vec, slong len, nmod_t mod) - void _nmod_vec_add(nn_ptr res, nn_srcptr vec1, nn_srcptr vec2, slong len, nmod_t mod) - void _nmod_vec_sub(nn_ptr res, nn_srcptr vec1, nn_srcptr vec2, slong len, nmod_t mod) - void _nmod_vec_neg(nn_ptr res, nn_srcptr vec, slong len, nmod_t mod) - void _nmod_vec_scalar_mul_nmod(nn_ptr res, nn_srcptr vec, slong len, ulong c, nmod_t mod) - void _nmod_vec_scalar_mul_nmod_shoup(nn_ptr res, nn_srcptr vec, slong len, ulong c, nmod_t mod) - void _nmod_vec_scalar_addmul_nmod(nn_ptr res, nn_srcptr vec, slong len, ulong c, nmod_t mod) - # dot_params_t _nmod_vec_dot_params(slong len, nmod_t mod) - # ulong _nmod_vec_dot(nn_srcptr vec1, nn_srcptr vec2, slong len, nmod_t mod, dot_params_t params) - # ulong _nmod_vec_dot_rev(nn_srcptr vec1, nn_srcptr vec2, slong len, nmod_t mod, dot_params_t params) - # ulong _nmod_vec_dot_ptr(nn_srcptr vec1, const nn_ptr * vec2, slong offset, slong len, nmod_t mod, dot_params_t params) - int _nmod_vec_dot_bound_limbs(slong len, nmod_t mod) - # int _nmod_vec_dot_bound_limbs_from_params(slong len, nmod_t mod, dot_params_t params) diff --git a/src/flint/flintlib/functions/partitions.pxd b/src/flint/flintlib/functions/partitions.pxd deleted file mode 100644 index 3b7ee421..00000000 --- a/src/flint/flintlib/functions/partitions.pxd +++ /dev/null @@ -1,13 +0,0 @@ -from flint.flintlib.types.arb cimport arb_t -from flint.flintlib.types.arf cimport arf_t -from flint.flintlib.types.flint cimport fmpz_t, slong, ulong - - - -cdef extern from "flint/partitions.h": - void partitions_rademacher_bound(arf_t b, const fmpz_t n, ulong N) - void partitions_hrr_sum_arb(arb_t x, const fmpz_t n, slong N0, slong N, int use_doubles) - void partitions_fmpz_fmpz(fmpz_t p, const fmpz_t n, int use_doubles) - void partitions_fmpz_ui(fmpz_t p, ulong n) - void partitions_fmpz_ui_using_doubles(fmpz_t p, ulong n) - void partitions_leading_fmpz(arb_t res, const fmpz_t n, slong prec) diff --git a/src/flint/flintlib/functions/ulong_extras.pxd b/src/flint/flintlib/functions/ulong_extras.pxd deleted file mode 100644 index afecc47d..00000000 --- a/src/flint/flintlib/functions/ulong_extras.pxd +++ /dev/null @@ -1,134 +0,0 @@ -from flint.flintlib.types.flint cimport flint_rand_t, fmpz_t, slong, ulong - -# unknown type n_ecm_t -# unknown type n_factor_t -# unknown type n_primes_t - - -cdef extern from "flint/ulong_extras.h": - ulong n_randlimb(flint_rand_t state) - ulong n_randbits(flint_rand_t state, unsigned int bits) - ulong n_randtest_bits(flint_rand_t state, int bits) - ulong n_randint(flint_rand_t state, ulong limit) - ulong n_urandint(flint_rand_t state, ulong limit) - ulong n_randtest(flint_rand_t state) - ulong n_randtest_not_zero(flint_rand_t state) - ulong n_randprime(flint_rand_t state, ulong bits, int proved) - ulong n_randtest_prime(flint_rand_t state, int proved) - ulong n_pow(ulong n, ulong exp) - ulong n_flog(ulong n, ulong b) - ulong n_clog(ulong n, ulong b) - ulong n_clog_2exp(ulong n, ulong b) - ulong n_revbin(ulong n, ulong b) - int n_sizeinbase(ulong n, int base) - ulong n_preinvert_limb_prenorm(ulong n) - ulong n_preinvert_limb(ulong n) - double n_precompute_inverse(ulong n) - ulong n_mod_precomp(ulong a, ulong n, double ninv) - ulong n_mod2_precomp(ulong a, ulong n, double ninv) - ulong n_divrem2_preinv(ulong * q, ulong a, ulong n, ulong ninv) - ulong n_div2_preinv(ulong a, ulong n, ulong ninv) - ulong n_mod2_preinv(ulong a, ulong n, ulong ninv) - ulong n_divrem2_precomp(ulong * q, ulong a, ulong n, double npre) - ulong n_ll_mod_preinv(ulong a_hi, ulong a_lo, ulong n, ulong ninv) - ulong n_lll_mod_preinv(ulong a_hi, ulong a_mi, ulong a_lo, ulong n, ulong ninv) - ulong n_mulmod_precomp(ulong a, ulong b, ulong n, double ninv) - ulong n_mulmod2_preinv(ulong a, ulong b, ulong n, ulong ninv) - ulong n_mulmod2(ulong a, ulong b, ulong n) - ulong n_mulmod_preinv(ulong a, ulong b, ulong n, ulong ninv, ulong norm) - ulong n_gcd(ulong x, ulong y) - ulong n_gcdinv(ulong * a, ulong x, ulong y) - ulong n_xgcd(ulong * a, ulong * b, ulong x, ulong y) - int n_jacobi(slong x, ulong y) - int n_jacobi_unsigned(ulong x, ulong y) - ulong n_addmod(ulong a, ulong b, ulong n) - ulong n_submod(ulong a, ulong b, ulong n) - ulong n_invmod(ulong x, ulong y) - ulong n_powmod_precomp(ulong a, slong exp, ulong n, double npre) - ulong n_powmod_ui_precomp(ulong a, ulong exp, ulong n, double npre) - ulong n_powmod(ulong a, slong exp, ulong n) - ulong n_powmod2_preinv(ulong a, slong exp, ulong n, ulong ninv) - ulong n_powmod2(ulong a, slong exp, ulong n) - ulong n_powmod2_ui_preinv(ulong a, ulong exp, ulong n, ulong ninv) - ulong n_powmod2_fmpz_preinv(ulong a, const fmpz_t exp, ulong n, ulong ninv) - ulong n_sqrtmod(ulong a, ulong p) - slong n_sqrtmod_2pow(ulong ** sqrt, ulong a, slong exp) - slong n_sqrtmod_primepow(ulong ** sqrt, ulong a, ulong p, slong exp) - # slong n_sqrtmodn(ulong ** sqrt, ulong a, n_factor_t * fac) - ulong n_mulmod_precomp_shoup(ulong a, ulong n) - void n_mulmod_precomp_shoup_quo_rem(ulong * a_pr_quo, ulong * a_pr_rem, ulong a, ulong n) - ulong n_mulmod_precomp_shoup_rem_from_quo(ulong a_pr_quo, ulong n) - ulong n_mulmod_shoup(ulong a, ulong b, ulong a_precomp, ulong n) - int n_divides(ulong * q, ulong n, ulong p) - # void n_primes_init(n_primes_t iter) - # void n_primes_clear(n_primes_t iter) - # ulong n_primes_next(n_primes_t iter) - # void n_primes_jump_after(n_primes_t iter, ulong n) - # void n_primes_extend_small(n_primes_t iter, ulong bound) - # void n_primes_sieve_range(n_primes_t iter, ulong a, ulong b) - void n_compute_primes(ulong num_primes) - const ulong * n_primes_arr_readonly(ulong num_primes) - const double * n_prime_inverses_arr_readonly(ulong n) - void n_cleanup_primes() - ulong n_nextprime(ulong n, int proved) - ulong n_prime_pi(ulong n) - void n_prime_pi_bounds(ulong * lo, ulong * hi, ulong n) - ulong n_nth_prime(ulong n) - void n_nth_prime_bounds(ulong * lo, ulong * hi, ulong n) - int n_is_oddprime_small(ulong n) - int n_is_oddprime_binary(ulong n) - int n_is_prime_pocklington(ulong n, ulong iterations) - int n_is_prime_pseudosquare(ulong n) - int n_is_prime(ulong n) - int n_is_strong_probabprime_precomp(ulong n, double npre, ulong a, ulong d) - int n_is_strong_probabprime2_preinv(ulong n, ulong ninv, ulong a, ulong d) - int n_is_probabprime_fermat(ulong n, ulong i) - int n_is_probabprime_fibonacci(ulong n) - int n_is_probabprime_BPSW(ulong n) - int n_is_probabprime_lucas(ulong n) - int n_is_probabprime(ulong n) - ulong n_CRT(ulong r1, ulong m1, ulong r2, ulong m2) - ulong n_sqrt(ulong a) - ulong n_sqrtrem(ulong * r, ulong a) - int n_is_square(ulong x) - int n_is_perfect_power235(ulong n) - int n_is_perfect_power(ulong * root, ulong n) - ulong n_rootrem(ulong * remainder, ulong n, ulong root) - ulong n_cbrt(ulong n) - ulong n_cbrt_binary_search(ulong n) - ulong n_cbrt_chebyshev_approx(ulong n) - ulong n_cbrtrem(ulong * remainder, ulong n) - # void n_factor_init(n_factor_t * factors) - # ulong n_factor_evaluate(const n_factor_t * factors) - int n_remove(ulong * n, ulong p) - int n_remove2_precomp(ulong * n, ulong p, double ppre) - # void n_factor_insert(n_factor_t * factors, ulong p, ulong exp) - # ulong n_factor_trial_range(n_factor_t * factors, ulong n, ulong start, ulong num_primes) - # ulong n_factor_trial(n_factor_t * factors, ulong n, ulong num_primes) - ulong n_factor_power235(ulong * exp, ulong n) - ulong n_factor_one_line(ulong n, ulong iters) - ulong n_factor_lehman(ulong n) - ulong n_factor_SQUFOF(ulong n, ulong iters) - # void n_factor(n_factor_t * factors, ulong n, int proved) - # ulong n_factor_trial_partial(n_factor_t * factors, ulong n, ulong * prod, ulong num_primes, ulong limit) - # ulong n_factor_partial(n_factor_t * factors, ulong n, ulong limit, int proved) - ulong n_factor_pp1(ulong n, ulong B1, ulong c) - ulong n_factor_pp1_wrapper(ulong n) - int n_factor_pollard_brent_single(ulong * factor, ulong n, ulong ninv, ulong ai, ulong xi, ulong normbits, ulong max_iters) - int n_factor_pollard_brent(ulong * factor, flint_rand_t state, ulong n_in, ulong max_tries, ulong max_iters) - int n_moebius_mu(ulong n) - void n_moebius_mu_vec(int * mu, ulong len) - int n_is_squarefree(ulong n) - ulong n_euler_phi(ulong n) - ulong n_factorial_fast_mod2_preinv(ulong n, ulong p, ulong pinv) - ulong n_factorial_mod2_preinv(ulong n, ulong p, ulong pinv) - # ulong n_primitive_root_prime_prefactor(ulong p, n_factor_t * factors) - ulong n_primitive_root_prime(ulong p) - ulong n_discrete_log_bsgs(ulong b, ulong a, ulong n) - # void n_factor_ecm_double(ulong * x, ulong * z, ulong x0, ulong z0, ulong n, n_ecm_t n_ecm_inf) - # void n_factor_ecm_add(ulong * x, ulong * z, ulong x1, ulong z1, ulong x2, ulong z2, ulong x0, ulong z0, ulong n, n_ecm_t n_ecm_inf) - # void n_factor_ecm_mul_montgomery_ladder(ulong * x, ulong * z, ulong x0, ulong z0, ulong k, ulong n, n_ecm_t n_ecm_inf) - # int n_factor_ecm_select_curve(ulong * f, ulong sigma, ulong n, n_ecm_t n_ecm_inf) - # int n_factor_ecm_stage_I(ulong * f, const ulong * prime_array, ulong num, ulong B1, ulong n, n_ecm_t n_ecm_inf) - # int n_factor_ecm_stage_II(ulong * f, ulong B1, ulong B2, ulong P, ulong n, n_ecm_t n_ecm_inf) - int n_factor_ecm(ulong * f, ulong curves, ulong B1, ulong B2, flint_rand_t state, ulong n) diff --git a/src/flint/flintlib/types/__init__.py b/src/flint/flintlib/types/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/flintlib/types/acb.pxd b/src/flint/flintlib/types/acb.pxd deleted file mode 100644 index 0d9daf57..00000000 --- a/src/flint/flintlib/types/acb.pxd +++ /dev/null @@ -1,46 +0,0 @@ -from flint.flintlib.types.flint cimport slong, ulong -from flint.flintlib.types.arb cimport arb_struct, arb_ptr, arb_poly_t, mag_struct - - -cdef extern from "flint/acb_types.h": - - ctypedef struct acb_struct: - arb_struct real - arb_struct imag - - ctypedef acb_struct acb_t[1] - ctypedef acb_struct * acb_ptr - ctypedef const acb_struct * acb_srcptr - - ctypedef struct acb_mat_struct: - acb_ptr entries - slong r - slong c - acb_ptr * rows - - ctypedef acb_mat_struct acb_mat_t[1] - - ctypedef struct acb_poly_struct: - acb_ptr coeffs - slong alloc - slong length - - ctypedef acb_poly_struct acb_poly_t[1] - - -cdef extern from "flint/acb.h": - - arb_ptr acb_realref(const acb_t x) - arb_ptr acb_imagref(const acb_t x) - - -cdef extern from "flint/acb_mat.h": - - acb_struct * acb_mat_entry(acb_mat_t mat, slong i, slong j) - slong acb_mat_nrows(const acb_mat_t x) - slong acb_mat_ncols(const acb_mat_t x) - - -cdef extern from "flint/acb_poly.h": - - acb_ptr acb_poly_get_coeff_ptr(arb_poly_t poly, slong n) diff --git a/src/flint/flintlib/types/acb_calc.pxd b/src/flint/flintlib/types/acb_calc.pxd deleted file mode 100644 index a702f0ae..00000000 --- a/src/flint/flintlib/types/acb_calc.pxd +++ /dev/null @@ -1,15 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.acb cimport acb_ptr, acb_t - -cdef extern from "flint/acb_calc.h": - - ctypedef int (*acb_calc_func_t)(acb_ptr out, const acb_t inp, void * param, slong order, slong prec) - - ctypedef struct acb_calc_integrate_opt_struct: - slong deg_limit - slong eval_limit - slong depth_limit - int use_heap - int verbose - - ctypedef acb_calc_integrate_opt_struct acb_calc_integrate_opt_t[1] diff --git a/src/flint/flintlib/types/acb_dirichlet.pxd b/src/flint/flintlib/types/acb_dirichlet.pxd deleted file mode 100644 index 9528a65b..00000000 --- a/src/flint/flintlib/types/acb_dirichlet.pxd +++ /dev/null @@ -1,27 +0,0 @@ -from flint.flintlib.types.flint cimport ulong, slong -from flint.flintlib.types.arb cimport mag_struct -from flint.flintlib.types.acb cimport acb_t, acb_ptr, acb_struct - -cdef extern from "flint/acb_dirichlet.h": - - ctypedef struct acb_dirichlet_roots_struct: - ulong order - ulong reduced_order - acb_t z - slong size - slong depth - acb_ptr * Z - int use_pow - - ctypedef acb_dirichlet_roots_struct acb_dirichlet_roots_t[1] - - ctypedef struct acb_dirichlet_hurwitz_precomp_struct: - acb_struct s - mag_struct err - acb_ptr coeffs - int deflate - slong A - slong N - slong K - - ctypedef acb_dirichlet_hurwitz_precomp_struct acb_dirichlet_hurwitz_precomp_t[1] diff --git a/src/flint/flintlib/types/acb_theta.pxd b/src/flint/flintlib/types/acb_theta.pxd deleted file mode 100644 index 7a252e91..00000000 --- a/src/flint/flintlib/types/acb_theta.pxd +++ /dev/null @@ -1,22 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.acb cimport acb_ptr, acb_srcptr, acb_t, acb_mat_t - -cdef extern from "flint/acb_theta.h": - - ctypedef struct acb_theta_eld_struct: - slong dim - slong ambient_dim - slong * last_coords - slong min - slong mid - slong max - slong nr - slong nl - acb_theta_eld_struct * rchildren - acb_theta_eld_struct * lchildren - slong nb_pts, nb_border - slong * box - - ctypedef acb_theta_eld_struct acb_theta_eld_t[1] - ctypedef void (*acb_theta_naive_worker_t)(acb_ptr, acb_srcptr, acb_srcptr, const slong *, slong, const acb_t, const slong *, slong, slong, slong, slong) - ctypedef int (*acb_theta_ql_worker_t)(acb_ptr, acb_srcptr, acb_srcptr, arb_srcptr, arb_srcptr, const acb_mat_t, slong, slong) diff --git a/src/flint/flintlib/types/arb.pxd b/src/flint/flintlib/types/arb.pxd deleted file mode 100644 index 211fcdf9..00000000 --- a/src/flint/flintlib/types/arb.pxd +++ /dev/null @@ -1,51 +0,0 @@ -from flint.flintlib.types.flint cimport ulong, slong, fmpz_struct -from flint.flintlib.types.arf cimport arf_struct, arf_ptr - -cdef extern from "flint/arb_types.h": - ctypedef struct mag_struct: - fmpz_struct exp - ulong man - - ctypedef mag_struct mag_t[1] - ctypedef mag_struct * mag_ptr - ctypedef const mag_struct * mag_srcptr - - ctypedef struct arb_struct: - arf_struct mid - mag_struct rad - - ctypedef arb_struct arb_t[1] - ctypedef arb_struct * arb_ptr - ctypedef const arb_struct * arb_srcptr - - ctypedef struct arb_mat_struct: - arb_ptr entries - slong r - slong c - arb_ptr * rows - - ctypedef arb_mat_struct arb_mat_t[1] - - ctypedef struct arb_poly_struct: - arb_ptr coeffs - slong alloc - slong length - - ctypedef arb_poly_struct arb_poly_t[1] - -cdef extern from "flint/arb_types.h": - # Macros - cdef arf_ptr arb_midref(const arb_t x) - cdef mag_ptr arb_radref(const arb_t x) - cdef const ulong ARB_STR_MORE - cdef const ulong ARB_STR_NO_RADIUS - cdef const ulong ARB_STR_CONDENSE - -cdef extern from "flint/arb_mat.h": - # Macros - arb_ptr arb_mat_entry(arb_mat_t mat, slong i, slong j) - slong arb_mat_nrows(arb_mat_t mat) - slong arb_mat_ncols(arb_mat_t mat) - -cdef extern from "flint/arb_poly.h": - void arb_poly_set_arb(arb_poly_t poly, const arb_t c) diff --git a/src/flint/flintlib/types/arf.pxd b/src/flint/flintlib/types/arf.pxd deleted file mode 100644 index 1ee8dab6..00000000 --- a/src/flint/flintlib/types/arf.pxd +++ /dev/null @@ -1,33 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_struct, slong, ulong, nn_ptr - -cdef extern from "flint/arf.h": - ctypedef enum arf_rnd_t: - ARF_RND_DOWN - ARF_RND_NEAR - ARF_RND_FLOOR - ARF_RND_CEIL - ARF_RND_UP - -cdef extern from "flint/arf_types.h": - - cdef const int ARF_NOPTR_LIMBS - - ctypedef struct mantissa_noptr_struct: - ulong d[ARF_NOPTR_LIMBS] - - ctypedef struct mantissa_ptr_struct: - slong alloc - nn_ptr d - - ctypedef union mantissa_struct: - mantissa_noptr_struct noptr - mantissa_ptr_struct ptr - - ctypedef struct arf_struct: - fmpz_struct exp - slong size - mantissa_struct d - - ctypedef arf_struct arf_t[1] - ctypedef arf_struct * arf_ptr - ctypedef const arf_struct * arf_srcptr diff --git a/src/flint/flintlib/types/arith.pxd b/src/flint/flintlib/types/arith.pxd deleted file mode 100644 index 60e34549..00000000 --- a/src/flint/flintlib/types/arith.pxd +++ /dev/null @@ -1,11 +0,0 @@ -from flint.flintlib.types.flint cimport ulong -from flint.flintlib.types.fmpz cimport fmpz_poly_t -from flint.flintlib.functions.fmpq_poly cimport fmpq_poly_t - - -cdef extern from "flint/arith.h": - # Macros - void arith_legendre_polynomial(fmpq_poly_t v, ulong n) - void arith_chebyshev_t_polynomial(fmpz_poly_t v, ulong n) - void arith_chebyshev_u_polynomial(fmpz_poly_t v, ulong n) - void arith_cyclotomic_polynomial(fmpz_poly_t v, ulong n) diff --git a/src/flint/flintlib/types/dirichlet.pxd b/src/flint/flintlib/types/dirichlet.pxd deleted file mode 100644 index 0e1c70f3..00000000 --- a/src/flint/flintlib/types/dirichlet.pxd +++ /dev/null @@ -1,26 +0,0 @@ -from flint.flintlib.types.flint cimport ulong -from flint.flintlib.functions.nmod cimport nmod_t - - -cdef extern from "flint/dirichlet.h": - - ctypedef struct dirichlet_group_struct: - ulong q - ulong q_even - nmod_t mod - ulong rad_q - ulong phi_q - long neven - long num - ulong expo - void * P - ulong * generators - ulong * PHI - ctypedef dirichlet_group_struct dirichlet_group_t[1] - - ctypedef struct dirichlet_char_struct: - ulong n - ulong * log - ctypedef dirichlet_char_struct dirichlet_char_t[1] - - cdef ulong DIRICHLET_CHI_NULL diff --git a/src/flint/flintlib/types/flint.pxd b/src/flint/flintlib/types/flint.pxd deleted file mode 100644 index 319771e7..00000000 --- a/src/flint/flintlib/types/flint.pxd +++ /dev/null @@ -1,108 +0,0 @@ -# _flint.pxd -# -# Define fundamental types and constants - -cdef extern from "Python.h": - ctypedef void PyObject - -cdef enum: - FMPZ_UNKNOWN = 0 - FMPZ_REF = 1 - FMPZ_TMP = 2 - - -# -# Note: ulong and slong are used throughout Flint/Arb. They are expected to be -# 32 bit unsigned and signed integer types on a 32 bit system and 64 bit on a -# 64 bit system. We denote them as unsigned long and long here which would be -# incorrect on 64 bit Windows but the definition here does not matter because -# their actual sizes will be determined by the values from gmp.h and -# flint/flint.h. Their size in bits (32 or 64) is recorded in the FLINT_BITS -# macro which is defined in flint/flint.h. -# - -cdef extern from "gmp.h": - ctypedef unsigned long ulong - ctypedef unsigned long mp_limb_t - ctypedef long mp_size_t - ctypedef long mp_exp_t - ctypedef mp_limb_t* mp_ptr - ctypedef mp_limb_t* mp_srcptr - ctypedef unsigned long mp_bitcnt_t - -cdef extern from "flint/fmpz.h": - ctypedef long slong - ctypedef ulong flint_bitcnt_t - ctypedef ulong * nn_ptr - ctypedef const ulong * nn_srcptr - -ctypedef slong fmpz_struct -ctypedef fmpz_struct fmpz_t[1] - -cdef extern from "flint/fmpz.h": - # Macros - int COEFF_IS_MPZ(fmpz_struct x) - -cdef extern from *: - """ - #if __FLINT_RELEASE < 30200 /* Flint < 3.2.0 */ - - /* Functions renamed in Flint 3.2.0 */ - #define flint_rand_init flint_randinit - #define flint_rand_clear flint_randclear - - #endif - """ - -cdef extern from "flint/flint.h": - # These defines are needed to work around a Cython bug. - # Otherwise sizeof(ulong) will give the wrong size on 64 bit Windows. - # https://github.com/cython/cython/issues/6339 - """ - #define SIZEOF_ULONG sizeof(ulong) - #define SIZEOF_SLONG sizeof(slong) - """ - int SIZEOF_ULONG - int SIZEOF_SLONG - - ctypedef struct __FLINT_FILE: - pass - ctypedef __FLINT_FILE FLINT_FILE - - const char * FLINT_VERSION - const int __FLINT_RELEASE - - const int FLINT_BITS - - ctypedef void * flint_rand_t - void flint_rand_init(flint_rand_t state) - void flint_rand_clear(flint_rand_t state) - - void flint_set_num_threads(long) - long flint_get_num_threads() - - void flint_cleanup() - - ctypedef struct nmod_t: - mp_limb_t n - mp_limb_t ninv - flint_bitcnt_t norm - - ctypedef struct fmpq: - fmpz_struct num - fmpz_struct den - -cdef extern from *: - """ - /* FLINT_BITS is not known until C compile time. We need to check if long - * or long long matches FLINT_BITS to know which CPython function to call. - */ - #if FLINT_BITS == 32 && LONG_MAX == 2147483647 - #define pylong_as_slong PyLong_AsLongAndOverflow - #elif FLINT_BITS == 64 && LLONG_MAX == 9223372036854775807 - #define pylong_as_slong PyLong_AsLongLongAndOverflow - #else - #error FLINT_BITS does not match width of long or long long. - #endif - """ - slong pylong_as_slong(PyObject *pylong, int *overflow) diff --git a/src/flint/flintlib/types/fmpq.pxd b/src/flint/flintlib/types/fmpq.pxd deleted file mode 100644 index 6f66d052..00000000 --- a/src/flint/flintlib/types/fmpq.pxd +++ /dev/null @@ -1,43 +0,0 @@ -from flint.flintlib.types.flint cimport slong, fmpz_struct, fmpz_t -from flint.flintlib.types.flint cimport fmpq as fmpq_struct -from flint.flintlib.types.fmpz cimport fmpz_mpoly_ctx_t, fmpz_mpoly_t - -cdef extern from "flint/fmpq_types.h": - - ctypedef fmpq_struct fmpq_t[1] - - ctypedef struct fmpq_mat_struct: - fmpq_struct * entries - slong r - slong c - fmpq_struct ** rows - - ctypedef fmpq_mat_struct fmpq_mat_t[1] - - ctypedef struct fmpq_poly_struct: - fmpz_struct * coeffs - slong alloc - slong length - fmpz_t den - - ctypedef fmpq_poly_struct fmpq_poly_t[1] - - ctypedef struct fmpq_mpoly_ctx_struct: - fmpz_mpoly_ctx_t zctx - - ctypedef fmpq_mpoly_ctx_struct fmpq_mpoly_ctx_t[1] - - ctypedef struct fmpq_mpoly_struct: - fmpq_t content - fmpz_mpoly_t zpoly - - ctypedef fmpq_mpoly_struct fmpq_mpoly_t[1] - - ctypedef struct fmpq_mpoly_factor_struct: - fmpq_t constant - fmpq_mpoly_struct * poly - fmpz_struct * exp - slong num - slong alloc - - ctypedef fmpq_mpoly_factor_struct fmpq_mpoly_factor_t[1] diff --git a/src/flint/flintlib/types/fmpz.pxd b/src/flint/flintlib/types/fmpz.pxd deleted file mode 100644 index 1a3cb374..00000000 --- a/src/flint/flintlib/types/fmpz.pxd +++ /dev/null @@ -1,128 +0,0 @@ -from flint.flintlib.types.flint cimport ( - mp_ptr, - fmpz_struct, - fmpz_t, - ulong, - slong, - flint_bitcnt_t, -) -from flint.flintlib.types.mpoly cimport mpoly_ctx_t - - -cdef extern from "flint/fmpz_types.h": - - ctypedef struct fmpz_preinvn_struct: - mp_ptr dinv - slong n - flint_bitcnt_t norm - ctypedef fmpz_preinvn_struct fmpz_preinvn_t[1] - - ctypedef struct fmpz_factor_struct: - int sign - fmpz_struct * p - ulong * exp - slong alloc - slong num - ctypedef fmpz_factor_struct fmpz_factor_t[1] - - ctypedef struct fmpz_mat_struct: - fmpz_struct * entries - slong r - slong c - fmpz_struct ** rows - ctypedef fmpz_mat_struct fmpz_mat_t[1] - long fmpz_mat_nrows(fmpz_mat_t mat) - long fmpz_mat_ncols(fmpz_mat_t mat) - - ctypedef struct fmpz_poly_struct: - fmpz_struct * coeffs - slong alloc - slong length - ctypedef fmpz_poly_struct fmpz_poly_t[1] - - ctypedef struct fmpz_poly_factor_struct: - fmpz_struct c - fmpz_poly_struct *p - slong *exp - slong num - slong alloc - ctypedef fmpz_poly_factor_struct fmpz_poly_factor_t[1] - - ctypedef struct fmpz_mpoly_ctx_struct: - mpoly_ctx_t minfo - - ctypedef fmpz_mpoly_ctx_struct fmpz_mpoly_ctx_t[1] - - ctypedef struct fmpz_mpoly_struct: - fmpz_struct * coeffs - ulong * exps - slong alloc - slong length - flint_bitcnt_t bits - - ctypedef fmpz_mpoly_struct fmpz_mpoly_t[1] - - ctypedef struct fmpz_mpoly_factor_struct: - fmpz_t constant - fmpz_t constant_den - fmpz_mpoly_struct * poly - fmpz_struct * exp - slong num - slong alloc - - ctypedef fmpz_mpoly_factor_struct fmpz_mpoly_factor_t[1] - - ctypedef struct fmpz_poly_q_struct: - fmpz_poly_struct *num - fmpz_poly_struct *den - - ctypedef fmpz_poly_q_struct fmpz_poly_q_t[1] - - ctypedef struct fmpz_mpoly_q_struct: - fmpz_mpoly_struct num - fmpz_mpoly_struct den - - ctypedef fmpz_mpoly_q_struct fmpz_mpoly_q_t[1] - - ctypedef struct fmpzi_struct: - fmpz_struct a - fmpz_struct b - - ctypedef fmpzi_struct fmpzi_t[1] - - -cdef extern from "flint/fmpz_factor.h": - # XXX: Missing from docs... - void fmpz_factor_expand(fmpz_t n, const fmpz_factor_t factor) - - -cdef extern from "flint/fmpz_mpoly.h": - - ctypedef struct fmpz_mpoly_vec_struct: - fmpz_mpoly_struct * p - slong alloc - slong length - - ctypedef fmpz_mpoly_vec_struct fmpz_mpoly_vec_t[1] - - # Macro - fmpz_mpoly_struct * fmpz_mpoly_vec_entry(fmpz_mpoly_vec_t vec, slong i) - -cdef extern from "flint/fmpz_lll.h": - - cdef enum _rep_type: - GRAM - Z_BASIS - ctypedef _rep_type rep_type - - cdef enum _gram_type: - APPROX - EXACT - ctypedef _gram_type gram_type - - ctypedef struct fmpz_lll_struct: - double delta - double eta - rep_type rt - gram_type gt - ctypedef fmpz_lll_struct fmpz_lll_t[1] diff --git a/src/flint/flintlib/types/fmpz_mod.pxd b/src/flint/flintlib/types/fmpz_mod.pxd deleted file mode 100644 index c294290a..00000000 --- a/src/flint/flintlib/types/fmpz_mod.pxd +++ /dev/null @@ -1,92 +0,0 @@ -from flint.flintlib.types.flint cimport ulong, slong, fmpz_struct, fmpz_t, nmod_t, flint_bitcnt_t -from flint.flintlib.types.fmpz cimport fmpz_struct, fmpz_preinvn_struct, fmpz_mat_struct -from flint.flintlib.types.mpoly cimport mpoly_ctx_t - - -cdef extern from "flint/fmpz_mod_types.h": - - ctypedef struct fmpz_mod_ctx_struct: - fmpz_t n - void (* add_fxn)(fmpz_t, const fmpz_t, const fmpz_t, const fmpz_mod_ctx_struct*) - void (* sub_fxn)(fmpz_t, const fmpz_t, const fmpz_t, const fmpz_mod_ctx_struct*) - void (* mul_fxn)(fmpz_t, const fmpz_t, const fmpz_t, const fmpz_mod_ctx_struct*) - nmod_t mod - ulong n_limbs[3] - ulong ninv_limbs[3] - fmpz_preinvn_struct * ninv_huge - - ctypedef fmpz_mod_ctx_struct fmpz_mod_ctx_t[1] - - ctypedef fmpz_mat_struct fmpz_mod_mat_struct - - ctypedef fmpz_mod_mat_struct fmpz_mod_mat_t[1] - - ctypedef struct fmpz_mod_poly_struct: - fmpz_struct * coeffs - slong alloc - slong length - - ctypedef fmpz_mod_poly_struct fmpz_mod_poly_t[1] - - ctypedef struct fmpz_mod_poly_factor_struct: - fmpz_mod_poly_struct * poly - slong *exp - slong num - slong alloc - - ctypedef fmpz_mod_poly_factor_struct fmpz_mod_poly_factor_t[1] - - ctypedef struct fmpz_mod_mpoly_ctx_struct: - mpoly_ctx_t minfo - fmpz_mod_ctx_t ffinfo - - ctypedef fmpz_mod_mpoly_ctx_struct fmpz_mod_mpoly_ctx_t[1] - - ctypedef struct fmpz_mod_mpoly_struct: - fmpz_struct * coeffs - ulong * exps - slong length - flint_bitcnt_t bits - slong coeffs_alloc - slong exps_alloc - - ctypedef fmpz_mod_mpoly_struct fmpz_mod_mpoly_t[1] - - ctypedef struct fmpz_mod_mpoly_factor_struct: - fmpz_t constant - fmpz_mod_mpoly_struct * poly - fmpz_struct * exp - slong num - slong alloc - - ctypedef fmpz_mod_mpoly_factor_struct fmpz_mod_mpoly_factor_t[1] - - -cdef extern from "flint/fmpz_mod.h": - - ctypedef struct fmpz_mod_discrete_log_pohlig_hellman_table_entry_struct: - fmpz_t gammapow - ulong cm - - ctypedef struct fmpz_mod_discrete_log_pohlig_hellman_entry_struct: - slong exp - ulong prime - fmpz_t gamma - fmpz_t gammainv - fmpz_t startingbeta - fmpz_t co - fmpz_t startinge - fmpz_t idem - ulong cbound - ulong dbound - fmpz_mod_discrete_log_pohlig_hellman_table_entry_struct * table # length cbound */ - - ctypedef struct fmpz_mod_discrete_log_pohlig_hellman_struct: - fmpz_mod_ctx_t fpctx - fmpz_t pm1 # p - 1 */ - fmpz_t alpha # p.r. of p */ - fmpz_t alphainv - slong num_factors # factors of p - 1 - fmpz_mod_discrete_log_pohlig_hellman_entry_struct * entries - - ctypedef fmpz_mod_discrete_log_pohlig_hellman_struct fmpz_mod_discrete_log_pohlig_hellman_t[1] diff --git a/src/flint/flintlib/types/fmpz_mod_mat_compat.pxd b/src/flint/flintlib/types/fmpz_mod_mat_compat.pxd deleted file mode 100644 index eadcc6a2..00000000 --- a/src/flint/flintlib/types/fmpz_mod_mat_compat.pxd +++ /dev/null @@ -1,124 +0,0 @@ -from flint.flintlib.types.flint cimport slong, fmpz_struct, fmpz_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t, fmpz_mod_mat_t, fmpz_mod_poly_t - -cdef extern from *: - """ - /* - * fmpz_mod_mat function signatures were changed in FLINT 3.1.0 - */ - #if __FLINT_RELEASE >= 30100 /* Flint 3.1.0 or later */ - - #define compat_fmpz_mod_mat_init(mat, rows, cols, ctx) fmpz_mod_mat_init(mat, rows, cols, ctx) - #define compat_fmpz_mod_mat_init_set(mat, src, ctx) fmpz_mod_mat_init_set(mat, src, ctx) - #define compat_fmpz_mod_mat_clear(mat, ctx) fmpz_mod_mat_clear(mat, ctx) - #define compat_fmpz_mod_mat_set(A, B, ctx) fmpz_mod_mat_set(A, B, ctx) - #define compat_fmpz_mod_mat_nrows(mat, ctx) fmpz_mod_mat_nrows(mat, ctx) - #define compat_fmpz_mod_mat_ncols(mat, ctx) fmpz_mod_mat_ncols(mat, ctx) - #define compat_fmpz_mod_mat_entry(mat, i, j) fmpz_mod_mat_entry(mat, i, j) - #define compat_fmpz_mod_mat_set_entry(mat, i, j, val, ctx) fmpz_mod_mat_set_entry(mat, i, j, val, ctx) - #define compat_fmpz_mod_mat_one(mat, ctx) fmpz_mod_mat_one(mat, ctx) - #define compat_fmpz_mod_mat_equal(mat1, mat2, ctx) fmpz_mod_mat_equal(mat1, mat2, ctx) - #define compat_fmpz_mod_mat_is_zero(mat, ctx) fmpz_mod_mat_is_zero(mat, ctx) - #define compat_fmpz_mod_mat_neg(B, A, ctx) fmpz_mod_mat_neg(B, A, ctx) - #define compat_fmpz_mod_mat_add(C, A, B, ctx) fmpz_mod_mat_add(C, A, B, ctx) - #define compat_fmpz_mod_mat_sub(C, A, B, ctx) fmpz_mod_mat_sub(C, A, B, ctx) - #define compat_fmpz_mod_mat_scalar_mul_fmpz(B, A, c, ctx) fmpz_mod_mat_scalar_mul_fmpz(B, A, c, ctx) - #define compat_fmpz_mod_mat_mul(C, A, B, ctx) fmpz_mod_mat_mul(C, A, B, ctx) - #define compat_fmpz_mod_mat_inv(B, A, ctx) fmpz_mod_mat_inv(B, A, ctx) - #define compat_fmpz_mod_mat_transpose(B, A, ctx) fmpz_mod_mat_transpose(B, A, ctx) - #define compat_fmpz_mod_mat_solve(X, A, B, ctx) fmpz_mod_mat_solve(X, A, B, ctx) - #define compat_fmpz_mod_mat_rref(mat, ctx) fmpz_mod_mat_rref(mat, mat, ctx) - #define compat_fmpz_mod_mat_charpoly(p, M, ctx) fmpz_mod_mat_charpoly(p, M, ctx) - #define compat_fmpz_mod_mat_minpoly(p, M, ctx) fmpz_mod_mat_minpoly(p, M, ctx) - - #else /* Flint 3.0.0 or 3.0.1 */ - - #define compat_fmpz_mod_mat_init(mat, rows, cols, ctx) fmpz_mod_mat_init(mat, rows, cols, ctx->n) - #define compat_fmpz_mod_mat_init_set(mat, src, ctx) fmpz_mod_mat_init_set(mat, src) - #define compat_fmpz_mod_mat_clear(mat, ctx) fmpz_mod_mat_clear(mat) - #define compat_fmpz_mod_mat_set(A, B, ctx) fmpz_mod_mat_set(A, B) - #define compat_fmpz_mod_mat_nrows(mat, ctx) fmpz_mod_mat_nrows(mat) - #define compat_fmpz_mod_mat_ncols(mat, ctx) fmpz_mod_mat_ncols(mat) - #define compat_fmpz_mod_mat_entry(mat, i, j) fmpz_mod_mat_entry(mat, i, j) - #define compat_fmpz_mod_mat_set_entry(mat, i, j, val, ctx) fmpz_mod_mat_set_entry(mat, i, j, val) - #define compat_fmpz_mod_mat_one(mat, ctx) fmpz_mod_mat_one(mat) - #define compat_fmpz_mod_mat_equal(mat1, mat2, ctx) fmpz_mod_mat_equal(mat1, mat2) - #define compat_fmpz_mod_mat_is_zero(mat, ctx) fmpz_mod_mat_is_zero(mat) - #define compat_fmpz_mod_mat_neg(B, A, ctx) fmpz_mod_mat_neg(B, A) - #define compat_fmpz_mod_mat_add(C, A, B, ctx) fmpz_mod_mat_add(C, A, B) - #define compat_fmpz_mod_mat_sub(C, A, B, ctx) fmpz_mod_mat_sub(C, A, B) - #define compat_fmpz_mod_mat_scalar_mul_fmpz(B, A, c, ctx) fmpz_mod_mat_scalar_mul_fmpz(B, A, c) - #define compat_fmpz_mod_mat_mul(C, A, B, ctx) fmpz_mod_mat_mul(C, A, B) - #define compat_fmpz_mod_mat_inv(B, A, ctx) fmpz_mod_mat_inv(B, A) - #define compat_fmpz_mod_mat_transpose(B, A, ctx) fmpz_mod_mat_transpose(B, A) - #define compat_fmpz_mod_mat_solve(X, A, B, ctx) fmpz_mod_mat_solve(X, A, B) - #define compat_fmpz_mod_mat_rref(mat, ctx) fmpz_mod_mat_rref(NULL, mat) - #define compat_fmpz_mod_mat_charpoly(p, M, ctx) fmpz_mod_mat_charpoly(p, M, ctx) - #define compat_fmpz_mod_mat_minpoly(p, M, ctx) fmpz_mod_mat_minpoly(p, M, ctx) - - #endif - """ - - -cdef extern from "flint/fmpz_mod_mat.h": - void compat_fmpz_mod_mat_init(fmpz_mod_mat_t mat, slong rows, slong cols, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_init_set(fmpz_mod_mat_t mat, const fmpz_mod_mat_t src, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_clear(fmpz_mod_mat_t mat, fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_set(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - slong compat_fmpz_mod_mat_nrows(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - slong compat_fmpz_mod_mat_ncols(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - fmpz_struct * compat_fmpz_mod_mat_entry(const fmpz_mod_mat_t mat, slong i, slong j) - void compat_fmpz_mod_mat_set_entry(fmpz_mod_mat_t mat, slong i, slong j, const fmpz_t val, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_one(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - int compat_fmpz_mod_mat_equal(const fmpz_mod_mat_t mat1, const fmpz_mod_mat_t mat2, const fmpz_mod_ctx_t ctx) - int compat_fmpz_mod_mat_is_zero(const fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_neg(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_add(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_sub(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_scalar_mul_fmpz(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, fmpz_t c, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_mul(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - int compat_fmpz_mod_mat_inv(fmpz_mod_mat_t B, fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_transpose(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, const fmpz_mod_ctx_t ctx) - int compat_fmpz_mod_mat_solve(fmpz_mod_mat_t X, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, const fmpz_mod_ctx_t ctx) - slong compat_fmpz_mod_mat_rref(fmpz_mod_mat_t mat, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_charpoly(fmpz_mod_poly_t p, const fmpz_mod_mat_t M, const fmpz_mod_ctx_t ctx) - void compat_fmpz_mod_mat_minpoly(fmpz_mod_poly_t p, const fmpz_mod_mat_t M, const fmpz_mod_ctx_t ctx) - # - # The functions below are unused. The signatures shown are for Flint < 3.1.0 - # Probably compat_ versions are needed but each signature should be checked - # against Flint 3.1.0 or later. For now we comment these out. - # - # void _fmpz_mod_mat_set_mod(fmpz_mod_mat_t mat, const fmpz_t n) - # void fmpz_mod_mat_zero(fmpz_mod_mat_t mat) - # void fmpz_mod_mat_swap(fmpz_mod_mat_t mat1, fmpz_mod_mat_t mat2) - # void fmpz_mod_mat_swap_entrywise(fmpz_mod_mat_t mat1, fmpz_mod_mat_t mat2) - # int fmpz_mod_mat_is_empty(const fmpz_mod_mat_t mat) - # int fmpz_mod_mat_is_square(const fmpz_mod_mat_t mat) - # void _fmpz_mod_mat_reduce(fmpz_mod_mat_t mat) - # void fmpz_mod_mat_randtest(fmpz_mod_mat_t mat, flint_rand_t state) - # void fmpz_mod_mat_window_init(fmpz_mod_mat_t window, const fmpz_mod_mat_t mat, slong r1, slong c1, slong r2, slong c2) - # void fmpz_mod_mat_window_clear(fmpz_mod_mat_t window) - # void fmpz_mod_mat_concat_horizontal(fmpz_mod_mat_t res, const fmpz_mod_mat_t mat1, const fmpz_mod_mat_t mat2) - # void fmpz_mod_mat_concat_vertical(fmpz_mod_mat_t res, const fmpz_mod_mat_t mat1, const fmpz_mod_mat_t mat2) - # void fmpz_mod_mat_print_pretty(const fmpz_mod_mat_t mat) - # void fmpz_mod_mat_set_fmpz_mat(fmpz_mod_mat_t A, const fmpz_mat_t B) - # void fmpz_mod_mat_get_fmpz_mat(fmpz_mat_t A, const fmpz_mod_mat_t B) - # void fmpz_mod_mat_scalar_mul_si(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, slong c) - # void fmpz_mod_mat_scalar_mul_ui(fmpz_mod_mat_t B, const fmpz_mod_mat_t A, ulong c) - # # unimported types {'thread_pool_handle'} - # # void _fmpz_mod_mat_mul_classical_threaded_pool_op(fmpz_mod_mat_t D, const fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, int op, thread_pool_handle * threads, slong num_threads) - # void _fmpz_mod_mat_mul_classical_threaded_op(fmpz_mod_mat_t D, const fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B, int op) - # void fmpz_mod_mat_mul_classical_threaded(fmpz_mod_mat_t C, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B) - # void fmpz_mod_mat_sqr(fmpz_mod_mat_t B, const fmpz_mod_mat_t A) - # void fmpz_mod_mat_mul_fmpz_vec(fmpz_struct * c, const fmpz_mod_mat_t A, const fmpz_struct * b, slong blen) - # void fmpz_mod_mat_mul_fmpz_vec_ptr(fmpz_struct * const * c, const fmpz_mod_mat_t A, const fmpz_struct * const * b, slong blen) - # void fmpz_mod_mat_fmpz_vec_mul(fmpz_struct * c, const fmpz_struct * a, slong alen, const fmpz_mod_mat_t B) - # void fmpz_mod_mat_fmpz_vec_mul_ptr(fmpz_struct * const * c, const fmpz_struct * const * a, slong alen, const fmpz_mod_mat_t B) - # void fmpz_mod_mat_trace(fmpz_t trace, const fmpz_mod_mat_t mat) - # void fmpz_mod_mat_strong_echelon_form(fmpz_mod_mat_t mat) - # slong fmpz_mod_mat_howell_form(fmpz_mod_mat_t mat) - # slong fmpz_mod_mat_lu(slong * P, fmpz_mod_mat_t A, int rank_check) - # void fmpz_mod_mat_solve_tril(fmpz_mod_mat_t X, const fmpz_mod_mat_t L, const fmpz_mod_mat_t B, int unit) - # void fmpz_mod_mat_solve_triu(fmpz_mod_mat_t X, const fmpz_mod_mat_t U, const fmpz_mod_mat_t B, int unit) - # int fmpz_mod_mat_can_solve(fmpz_mod_mat_t X, const fmpz_mod_mat_t A, const fmpz_mod_mat_t B) - # void fmpz_mod_mat_similarity(fmpz_mod_mat_t M, slong r, fmpz_t d) diff --git a/src/flint/flintlib/types/fmpz_mod_poly.pxd b/src/flint/flintlib/types/fmpz_mod_poly.pxd deleted file mode 100644 index 688c0bc7..00000000 --- a/src/flint/flintlib/types/fmpz_mod_poly.pxd +++ /dev/null @@ -1,72 +0,0 @@ -from flint.flintlib.types.flint cimport slong, fmpz_struct, fmpz_t -from flint.flintlib.types.fmpz cimport fmpz_mat_struct -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_struct - - -cdef extern from "flint/fmpz_mod_poly.h": - - # Type definitions *********************************************************/ - ctypedef struct fmpz_mod_poly_struct: - fmpz_struct * coeffs - slong alloc - slong length - - ctypedef fmpz_mod_poly_struct fmpz_mod_poly_t[1] - - ctypedef struct fmpz_mod_poly_res_struct: - fmpz_t res - fmpz_t lc - slong len0 - slong len1 - slong off - - ctypedef fmpz_mod_poly_res_struct fmpz_mod_poly_res_t[1] - - ctypedef struct fmpz_mod_poly_frobenius_powers_2exp_struct: - fmpz_mod_poly_struct * pow - slong len - - ctypedef fmpz_mod_poly_frobenius_powers_2exp_struct fmpz_mod_poly_frobenius_powers_2exp_t[1] - - ctypedef struct fmpz_mod_poly_frobenius_powers_struct: - fmpz_mod_poly_struct * pow - slong len - - ctypedef fmpz_mod_poly_frobenius_powers_struct fmpz_mod_poly_frobenius_powers_t[1] - - ctypedef struct fmpz_mod_poly_matrix_precompute_arg_t: - fmpz_mat_struct * A - fmpz_mod_poly_struct * poly1 - fmpz_mod_poly_struct * poly2 - fmpz_mod_poly_struct * poly2inv - const fmpz_mod_ctx_struct * ctx - - ctypedef struct fmpz_mod_poly_compose_mod_precomp_preinv_arg_t: - fmpz_mat_struct * A - fmpz_mod_poly_struct * res - fmpz_mod_poly_struct * poly1 - fmpz_mod_poly_struct * poly3 - fmpz_mod_poly_struct * poly3inv - const fmpz_mod_ctx_struct * ctx - - # Radix conversion *********************************************************/ - ctypedef struct fmpz_mod_poly_radix_struct: - fmpz_struct *V - fmpz_struct *W - fmpz_struct **Rpow - fmpz_struct **Rinv - slong degR - slong k - fmpz_struct invL - - ctypedef fmpz_mod_poly_radix_struct fmpz_mod_poly_radix_t[1] - - # Berlekamp-Massey Algorithm - see fmpz_mod_poly/berlekamp_massey.c for more info ********/ - ctypedef struct fmpz_mod_berlekamp_massey_struct: - slong npoints - fmpz_mod_poly_t R0, R1 - fmpz_mod_poly_t V0, V1 - fmpz_mod_poly_t qt, rt - fmpz_mod_poly_t points - - ctypedef fmpz_mod_berlekamp_massey_struct fmpz_mod_berlekamp_massey_t[1] diff --git a/src/flint/flintlib/types/fq.pxd b/src/flint/flintlib/types/fq.pxd deleted file mode 100644 index 91877fbb..00000000 --- a/src/flint/flintlib/types/fq.pxd +++ /dev/null @@ -1,47 +0,0 @@ -from flint.flintlib.types.flint cimport fmpz_struct, slong -from flint.flintlib.types.fmpz cimport fmpz_poly_t, fmpz_poly_struct -from flint.flintlib.functions.fmpz_mod cimport fmpz_mod_ctx_t -from flint.flintlib.functions.fmpz_mod_poly cimport fmpz_mod_poly_t - - -cdef extern from "flint/fq.h": - # Type definitions **********************************************/ - ctypedef fmpz_poly_t fq_t - ctypedef fmpz_poly_struct fq_struct - - ctypedef struct fq_ctx_struct: - fmpz_mod_ctx_t ctxp - - int sparse_modulus - int is_conway # whether field was initialized with the Flint Conway tables (assures primitivity) - - fmpz_struct * a - slong * j - slong len - - fmpz_mod_poly_t modulus - fmpz_mod_poly_t inv - - char * var - ctypedef fq_ctx_struct fq_ctx_t[1] - - ctypedef struct fq_mat_struct: - fq_struct * entries - slong r - slong s - fq_struct ** rows - ctypedef fq_mat_struct fq_mat_t[1] - - ctypedef struct fq_poly_struct: - fq_struct * coeffs - slong alloc - slong length - ctypedef fq_poly_struct fq_poly_t[1] - - ctypedef struct fq_poly_factor_struct: - fq_poly_struct * poly - slong * exp - slong num - slong alloc - - ctypedef fq_poly_factor_struct fq_poly_factor_t[1] diff --git a/src/flint/flintlib/types/fq_default.pxd b/src/flint/flintlib/types/fq_default.pxd deleted file mode 100644 index f2514c0d..00000000 --- a/src/flint/flintlib/types/fq_default.pxd +++ /dev/null @@ -1,64 +0,0 @@ -from flint.flintlib.types.flint cimport ulong, fmpz_t -from flint.flintlib.types.nmod cimport nmod_t, nmod_mat_t, nmod_poly_t, nmod_poly_factor_t -from flint.flintlib.types.fmpz_mod cimport fmpz_mod_ctx_t, fmpz_mod_mat_t, fmpz_mod_poly_t, fmpz_mod_poly_factor_t -from flint.flintlib.types.fq_nmod cimport fq_nmod_t, fq_nmod_ctx_t, fq_nmod_mat_t, fq_nmod_poly_t, fq_nmod_poly_factor_t -from flint.flintlib.types.fq_zech cimport fq_zech_t, fq_zech_ctx_t, fq_zech_mat_t, fq_zech_poly_t, fq_zech_poly_factor_t -from flint.flintlib.types.fq cimport fq_t, fq_ctx_t, fq_mat_t, fq_poly_t, fq_poly_factor_t - - -cdef extern from "flint/fq_default.h": - - ctypedef union fq_default_struct: - fq_t fq - fq_nmod_t fq_nmod - fq_zech_t fq_zech - ulong nmod - fmpz_t fmpz_mod - ctypedef fq_default_struct fq_default_t[1] - - ctypedef struct fq_default_fmpz_mod_ctx_struct: - fmpz_mod_ctx_t mod - fmpz_t a # minpoly is x - a - - ctypedef struct fq_default_nmod_ctx_struct: - nmod_t mod - ulong a # minpoly is x - a - - # This is how it is actually defined now: - # ctypedef gr_ctx_struct fq_default_ctx_struct; - # ctypedef fq_default_ctx_struct fq_default_ctx_t[1]; - - ctypedef union fq_default_ctx_struct: - fq_ctx_t fq - fq_nmod_ctx_t fq_nmod - fq_zech_ctx_t fq_zech - fq_default_nmod_ctx_struct nmod - fq_default_fmpz_mod_ctx_struct fmpz_mod - - ctypedef fq_default_ctx_struct fq_default_ctx_t[1] - - ctypedef union fq_default_mat_struct: - fq_mat_t fq - fq_nmod_mat_t fq_nmod - fq_zech_mat_t fq_zech - nmod_mat_t nmod - fmpz_mod_mat_t fmpz_mod - ctypedef fq_default_mat_struct fq_default_mat_t[1] - - ctypedef union fq_default_poly_struct: - fq_poly_t fq - fq_nmod_poly_t fq_nmod - fq_zech_poly_t fq_zech - nmod_poly_t nmod - fmpz_mod_poly_t fmpz_mod - - ctypedef fq_default_poly_struct fq_default_poly_t[1] - - ctypedef union fq_default_poly_factor_struct: - fq_poly_factor_t fq - fq_nmod_poly_factor_t fq_nmod - fq_zech_poly_factor_t fq_zech - nmod_poly_factor_t nmod - fmpz_mod_poly_factor_t fmpz_mod - - ctypedef fq_default_poly_factor_struct fq_default_poly_factor_t[1] diff --git a/src/flint/flintlib/types/fq_nmod.pxd b/src/flint/flintlib/types/fq_nmod.pxd deleted file mode 100644 index dabb65c3..00000000 --- a/src/flint/flintlib/types/fq_nmod.pxd +++ /dev/null @@ -1,54 +0,0 @@ -from flint.flintlib.types.flint cimport mp_limb_t, slong -from flint.flintlib.functions.fmpz cimport fmpz_struct -from flint.flintlib.functions.nmod cimport nmod_t -from flint.flintlib.functions.nmod_poly cimport nmod_poly_struct, nmod_poly_t -from flint.flintlib.types.mpoly cimport mpoly_ctx_t - - -cdef extern from "flint/fq_nmod.h": - # Type definitions **********************************************/ - ctypedef nmod_poly_t fq_nmod_t - ctypedef nmod_poly_struct fq_nmod_struct - - ctypedef struct fq_nmod_ctx_struct: - fmpz_struct p - nmod_t mod - - int sparse_modulus - int is_conway # whether field was generated using Flint Conway table (assures primitivity - - mp_limb_t *a - slong *j - slong len - - nmod_poly_t modulus - nmod_poly_t inv - - char *var - ctypedef fq_nmod_ctx_struct fq_nmod_ctx_t[1] - - ctypedef struct fq_nmod_poly_struct: - fq_nmod_struct * coeffs - slong alloc - slong length - ctypedef fq_nmod_poly_struct fq_nmod_poly_t[1] - - ctypedef struct fq_nmod_poly_factor_struct: - fq_nmod_poly_struct * poly - slong * exp - slong num - slong alloc - ctypedef fq_nmod_poly_factor_struct fq_nmod_poly_factor_t[1] - - ctypedef struct fq_nmod_mat_struct: - fq_nmod_struct * entries - slong r - slong s - fq_nmod_struct ** rows - ctypedef fq_nmod_mat_struct fq_nmod_mat_t[1] - - ctypedef struct fq_nmod_mpoly_ctx_struct: - mpoly_ctx_t minfo - fq_nmod_ctx_t fqctx - - ctypedef fq_nmod_mpoly_ctx_struct fq_nmod_mpoly_ctx_t[1] diff --git a/src/flint/flintlib/types/fq_zech.pxd b/src/flint/flintlib/types/fq_zech.pxd deleted file mode 100644 index 0faebdc1..00000000 --- a/src/flint/flintlib/types/fq_zech.pxd +++ /dev/null @@ -1,50 +0,0 @@ -from flint.flintlib.types.flint cimport slong, ulong -from flint.flintlib.types.fq_nmod cimport fq_nmod_ctx_struct - - -cdef extern from "flint/fq_zech.h": - - ctypedef struct fq_zech_struct: - ulong value - - ctypedef fq_zech_struct fq_zech_t[1] - - ctypedef struct fq_zech_ctx_struct: - ulong qm1 # q - 1 - ulong qm1o2 # (q - 1) / 2 or 1 when p == 2 - ulong qm1opm1 # (q - 1) / (p - 1) - ulong p - double ppre - ulong prime_root # primitive root for prime subfield - ulong * zech_log_table - ulong * prime_field_table - ulong * eval_table - - fq_nmod_ctx_struct * fq_nmod_ctx - int owns_fq_nmod_ctx - int is_conway # whether field was generated using Flint Conway tables (assures primitivity) - - ctypedef fq_zech_ctx_struct fq_zech_ctx_t[1] - - ctypedef struct fq_zech_mat_struct: - fq_zech_struct * entries - slong r - slong s - fq_zech_struct ** rows - - ctypedef fq_zech_mat_struct fq_zech_mat_t[1] - - ctypedef struct fq_zech_poly_struct: - fq_zech_struct * coeffs - slong alloc - slong length - - ctypedef fq_zech_poly_struct fq_zech_poly_t[1] - - ctypedef struct fq_zech_poly_factor_struct: - fq_zech_poly_struct * poly - slong * exp - slong num - slong alloc - - ctypedef fq_zech_poly_factor_struct fq_zech_poly_factor_t[1] diff --git a/src/flint/flintlib/types/gr.pxd b/src/flint/flintlib/types/gr.pxd deleted file mode 100644 index 84bdc8b8..00000000 --- a/src/flint/flintlib/types/gr.pxd +++ /dev/null @@ -1,102 +0,0 @@ -from flint.flintlib.types.flint cimport ( - FLINT_FILE, - slong, - ulong, - flint_bitcnt_t, -) - -cdef extern from *: - """ - /* - * The following functions were introduced in FLINT 3.1.0 - */ - #if __FLINT_RELEASE < 30100 - #define gr_div_nonunique(res, x, y, ctx) GR_UNABLE - #endif - - /* - * The following functions were introduced in FLINT 3.2.0 - */ - #if __FLINT_RELEASE < 30200 - #define gr_min(res, x, y, ctx) GR_UNABLE - #define gr_max(res, x, y, ctx) GR_UNABLE - #define gr_le(x, y, ctx) T_UNKNOWN - #define gr_lt(x, y, ctx) T_UNKNOWN - #define gr_ge(x, y, ctx) T_UNKNOWN - #define gr_gt(x, y, ctx) T_UNKNOWN - #define gr_abs_le(x, y, ctx) T_UNKNOWN - #define gr_abs_lt(x, y, ctx) T_UNKNOWN - #define gr_abs_ge(x, y, ctx) T_UNKNOWN - #define gr_abs_gt(x, y, ctx) T_UNKNOWN - #endif - """ - - -cdef extern from "flint/gr.h": - - ctypedef int truth_t - cdef int T_TRUE - cdef int T_FALSE - cdef int T_UNKNOWN - - # Macros - cdef int GR_SUCCESS - cdef int GR_DOMAIN - cdef int GR_UNABLE - - ctypedef struct gr_stream_struct: - FLINT_FILE * fp - char * s - slong len - slong alloc - - ctypedef gr_stream_struct gr_stream_t[1] - - ctypedef int (*gr_funcptr)() - - cdef const int GR_CTX_STRUCT_DATA_BYTES - - cdef struct gr_ctx_struct: - char data[GR_CTX_STRUCT_DATA_BYTES] - ulong which_ring - slong sizeof_elem - gr_funcptr * methods - ulong size_limit - - ctypedef gr_ctx_struct gr_ctx_t[1] - - ctypedef void * gr_ptr - ctypedef const void * gr_srcptr - ctypedef void * gr_ctx_ptr - - ctypedef struct gr_vec_struct: - gr_ptr entries - slong alloc - slong length - - ctypedef gr_vec_struct gr_vec_t[1] - - ctypedef struct gr_mat_struct: - gr_ptr entries - slong r - slong c - gr_ptr * rows - - ctypedef gr_mat_struct gr_mat_t[1] - - ctypedef struct gr_poly_struct: - gr_ptr coeffs - slong alloc - slong length - - ctypedef gr_poly_struct gr_poly_t[1] - - ctypedef struct gr_mpoly_struct: - gr_ptr coeffs - ulong * exps - slong length - flint_bitcnt_t bits # number of bits per exponent - slong coeffs_alloc # abs size in ulong units - slong exps_alloc # abs size in ulong units - - ctypedef gr_mpoly_struct gr_mpoly_t[1] diff --git a/src/flint/flintlib/types/mpoly.pxd b/src/flint/flintlib/types/mpoly.pxd deleted file mode 100644 index b05300ac..00000000 --- a/src/flint/flintlib/types/mpoly.pxd +++ /dev/null @@ -1,22 +0,0 @@ -from flint.flintlib.types.flint cimport slong, FLINT_BITS - -cdef extern from "flint/mpoly.h": - - ctypedef enum ordering_t: - ORD_LEX - ORD_DEGLEX - ORD_DEGREVLEX - - ctypedef struct mpoly_ctx_struct: - slong nvars - slong nfields - ordering_t ord - int deg - int rev - slong lut_words_per_exp[FLINT_BITS] - unsigned char lut_fix_bits[FLINT_BITS] - - ctypedef mpoly_ctx_struct mpoly_ctx_t[1] - - void mpoly_ctx_init(mpoly_ctx_t ctx, slong nvars, const ordering_t ord) - void mpoly_ctx_clear(mpoly_ctx_t mctx) diff --git a/src/flint/flintlib/types/nmod.pxd b/src/flint/flintlib/types/nmod.pxd deleted file mode 100644 index c1324908..00000000 --- a/src/flint/flintlib/types/nmod.pxd +++ /dev/null @@ -1,75 +0,0 @@ -from flint.flintlib.types.flint cimport ulong, slong, nmod_t, fmpz_struct, nn_ptr, flint_bitcnt_t -from flint.flintlib.types.mpoly cimport mpoly_ctx_t - - -cdef extern from "flint/nmod_types.h": - - ctypedef struct nmod_mat_struct: - ulong * entries - slong r - slong c - ulong ** rows - nmod_t mod - - ctypedef nmod_mat_struct nmod_mat_t[1] - - # Macros: - ulong nmod_mat_entry(nmod_mat_t mat, slong i, slong j) - - ctypedef struct nmod_poly_struct: - nn_ptr coeffs - slong alloc - slong length - nmod_t mod - - ctypedef nmod_poly_struct nmod_poly_t[1] - - ctypedef struct nmod_poly_factor_struct: - nmod_poly_struct * p - slong *exp - slong num - slong alloc - - ctypedef nmod_poly_factor_struct nmod_poly_factor_t[1] - - ctypedef struct nmod_poly_mat_struct: - nmod_poly_struct * entries - slong r - slong c - nmod_poly_struct ** rows - ulong modulus - - ctypedef nmod_poly_mat_struct nmod_poly_mat_t[1] - - ctypedef struct nmod_mpoly_ctx_struct: - mpoly_ctx_t minfo - nmod_t mod - - ctypedef nmod_mpoly_ctx_struct nmod_mpoly_ctx_t[1] - - ctypedef struct nmod_mpoly_struct: - ulong * coeffs - ulong * exps - slong length - flint_bitcnt_t bits - slong coeffs_alloc - slong exps_alloc - - ctypedef nmod_mpoly_struct nmod_mpoly_t[1] - - ctypedef struct nmod_mpoly_univar_struct: - nmod_mpoly_struct * coeffs - fmpz_struct * exps - slong alloc - slong length - - ctypedef nmod_mpoly_univar_struct nmod_mpoly_univar_t[1] - - ctypedef struct nmod_mpoly_factor_struct: - ulong constant - nmod_mpoly_struct * poly - fmpz_struct * exp - slong num - slong alloc - - ctypedef nmod_mpoly_factor_struct nmod_mpoly_factor_t[1] diff --git a/src/flint/flintlib/types/undocumented.pxd b/src/flint/flintlib/types/undocumented.pxd deleted file mode 100644 index 247a3912..00000000 --- a/src/flint/flintlib/types/undocumented.pxd +++ /dev/null @@ -1,12 +0,0 @@ -from flint.flintlib.types.nmod cimport nmod_mat_t - -from flint.flintlib.types.flint cimport fmpz_struct -from flint.flintlib.types.nmod cimport nmod_mpoly_ctx_t, nmod_mpoly_t - -cdef extern from "flint/nmod_types.h": - int nmod_mat_is_square(const nmod_mat_t mat) - -cdef extern from "flint/nmod_mpoly.h": - void nmod_mpoly_deflation(fmpz_struct * shift, fmpz_struct * stride, const nmod_mpoly_t A, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_deflate(nmod_mpoly_t A, const nmod_mpoly_t B, const fmpz_struct * shift, const fmpz_struct * stride, const nmod_mpoly_ctx_t ctx) - void nmod_mpoly_inflate(nmod_mpoly_t A, const nmod_mpoly_t B, const fmpz_struct * shift, const fmpz_struct * stride, const nmod_mpoly_ctx_t ctx) diff --git a/src/flint/functions/__init__.py b/src/flint/functions/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/functions/meson.build b/src/flint/functions/meson.build deleted file mode 100644 index 46d1102f..00000000 --- a/src/flint/functions/meson.build +++ /dev/null @@ -1,24 +0,0 @@ -pyfiles = [ - '__init__.py', -] - -exts = [ - 'showgood', -] - -py.install_sources( - pyfiles, - pure: false, - subdir: 'flint/functions', -) - -foreach ext : exts - py.extension_module( - ext, - ext + '.pyx', - dependencies: pyflint_deps, - install: true, - subdir: 'flint/functions', - limited_api: limited_api_version, - ) -endforeach diff --git a/src/flint/functions/showgood.pyx b/src/flint/functions/showgood.pyx deleted file mode 100644 index 4834d447..00000000 --- a/src/flint/functions/showgood.pyx +++ /dev/null @@ -1,132 +0,0 @@ -from flint.flint_base.flint_context cimport thectx -from flint.utils.conversion cimport dps_to_prec -from flint.types.arb_mat cimport arb_mat -from flint.types.acb_mat cimport acb_mat -from flint.types.arb_poly cimport arb_poly -from flint.types.acb_poly cimport acb_poly -from flint.types.arb cimport arb -from flint.types.acb cimport acb -from flint.types.arb_series cimport arb_series -from flint.types.acb_series cimport acb_series -from flint.flintlib.functions.arb cimport * -from flint.flintlib.functions.acb cimport * - -ctx = thectx - -cdef slong __goodness(x, bint parts, metric): - if metric is not None: - x = metric(x) - if isinstance(x, arb): - return arb_rel_accuracy_bits((x).val) - if isinstance(x, acb): - if parts: - return min(__goodness(x.real, parts, metric), __goodness(x.imag, parts, metric)) - else: - return acb_rel_accuracy_bits((x).val) - if isinstance(x, (tuple, list, arb_mat, acb_mat, arb_poly, acb_poly, arb_series, acb_series)): - return min(__goodness(y, parts, metric) for y in x) - raise TypeError("must have arb or acb") - -cdef goodstr(x): - if isinstance(x, tuple): - return "(" + ", ".join(goodstr(y) for y in x) + ")" - if isinstance(x, list): - return "[" + ", ".join(goodstr(y) for y in x) + "]" - if isinstance(x, (arb, acb, arb_mat, acb_mat, arb_poly, acb_poly, arb_series, acb_series)): - return x.str(radius=False) - raise TypeError("must be a element/tuple/list of arb, acb, arb_mat, acb_mat, arb_poly, acb_poly, arb_series, or acb_series") - - -def good(func, slong prec=0, slong maxprec=0, slong dps=0, - slong maxdps=0, slong padding=10, bint verbose=False, - bint show=False, bint parts=True, metric=None): - """ - Evaluates *func*, automatically increasing the precision to get - a result accurate to the current working precision (or the - precision specified by *prec* or *dps*). - - >>> from flint import arb - >>> good(lambda: (arb.pi() + arb("1e-100")).sin()) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=630, try higher maxprec) - >>> good(lambda: (arb.pi() + arb("1e-100")).sin(), maxprec=1000) - [-1.00000000000000e-100 +/- 3e-119] - - The function *func* can return an *arb*, an *acb*, or a composite - object such as a tuple or a matrix. By default all real and - imaginary parts of all components must be accurate. This means - that convergence is not possible in case of inexact zeros. - This behavior can be overridden by setting *parts* to *False*. - - >>> from flint import acb - >>> good(lambda: (acb(0,-1) ** 0.5) ** 2) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=630, try higher maxprec) - >>> good(lambda: (acb(0,-1) ** 0.5) ** 2, parts=False) - [+/- 4.50e-22] + [-1.00000000000000 +/- 3e-20]j - - - """ - cdef slong orig, morebits, acc - - if dps > 0: - prec = dps_to_prec(dps) - if maxdps > 0: - maxprec = dps_to_prec(maxdps) - - if prec == 0: - prec = ctx.prec - if maxprec == 0: - maxprec = 10 * prec + 100 - - if metric == "abssum": - def metric(L): return sum(abs(c) for c in L) - - # for printing - if dps == 0: - dps = ctx.dps - - orig = ctx.prec - morebits = max(20, prec // 5) - - if verbose: - print("prec = %i, maxprec = %i" % (prec, maxprec)) - try: - ctx.prec = prec * 1.01 + 2 * padding - while ctx.prec < maxprec: - if verbose: - print("eval prec = %i" % ctx.prec) - v = func() - acc = __goodness(v, parts, metric) - if verbose: - print("good bits = %i" % acc) - if acc > prec + padding: - if show: - ctx.dps = dps - print(goodstr(v)) - return - else: - return v - ctx.prec += morebits - morebits *= 2 - finally: - ctx.prec = orig - raise ValueError("no convergence (maxprec=%i, try higher maxprec)" % maxprec) - - -def showgood(func, **kwargs): - """ - Evaluates *func* accurately with :func:`good`, printing the decimal - value of the result (without an explicit radius) instead - of returning it. - - >>> from flint import arb - >>> showgood(lambda: arb.pi()) - 3.14159265358979 - >>> showgood(lambda: arb.pi(), dps=50) - 3.1415926535897932384626433832795028841971693993751 - """ - kwargs["show"] = True - good(func, **kwargs) diff --git a/src/flint/meson.build b/src/flint/meson.build deleted file mode 100644 index f76c7781..00000000 --- a/src/flint/meson.build +++ /dev/null @@ -1,40 +0,0 @@ -thisdir = 'flint' - -pyfiles = [ - '__init__.py', - 'typing.py', - 'py.typed', -] - -exts = [ - 'pyflint', -] - -pkgs = [ - 'flint_base', - 'types', - 'functions', - 'utils', - 'test', -] - -py.install_sources( - pyfiles, - pure: false, - subdir: thisdir, -) - -foreach ext : exts - py.extension_module( - ext, - ext + '.pyx', - dependencies: pyflint_deps, - install: true, - subdir: thisdir, - limited_api: limited_api_version, - ) -endforeach - -foreach pkg : pkgs - subdir(pkg) -endforeach diff --git a/src/flint/py.typed b/src/flint/py.typed deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/pyflint.pxd b/src/flint/pyflint.pxd deleted file mode 100644 index 69a0edef..00000000 --- a/src/flint/pyflint.pxd +++ /dev/null @@ -1,16 +0,0 @@ -from flint.flintlib.functions.arf cimport arf_rnd_t -from flint.flint_base.flint_base cimport flint_mat -from flint.flint_base.flint_base cimport flint_mpoly -from flint.flint_base.flint_base cimport flint_series -from flint.flint_base.flint_base cimport flint_scalar -from flint.flint_base.flint_base cimport flint_poly - -from flint.types.fmpz cimport fmpz -from flint.flintlib.types.flint cimport * - -cdef flint_rand_t global_random_state - -cdef class Context: - cdef public bint pretty - cdef public long prec - cdef arf_rnd_t rnd diff --git a/src/flint/pyflint.pyx b/src/flint/pyflint.pyx deleted file mode 100644 index 3765d437..00000000 --- a/src/flint/pyflint.pyx +++ /dev/null @@ -1,13 +0,0 @@ -""" -Python wrapper for FLINT and Arb. -""" - -# cimport flint -cimport libc.stdlib - -from flint.flint_base.flint_context cimport thectx - -cdef flint_rand_t global_random_state -flint_rand_init(global_random_state) - -ctx = thectx diff --git a/src/flint/test/__init__.py b/src/flint/test/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/test/__main__.py b/src/flint/test/__main__.py deleted file mode 100644 index 01813465..00000000 --- a/src/flint/test/__main__.py +++ /dev/null @@ -1,137 +0,0 @@ -# -# Run the python-flint test-suite as -# -# python -m flint.test -# - -import sys -import doctest -import traceback -import argparse - -import flint -from flint.test.test_all import all_tests -from flint.test.test_docstrings import find_doctests - - -def run_tests(verbose=None): - """Run all tests - - This is usually called by - - $ python -m flint.flint - """ - # Show the limited output by default - if verbose is None: - verbose = True - - total = 0 - failed = 0 - - for test in all_tests: - - if verbose: - print(f'{test.__name__}...', end='', flush=True) - - try: - test() - except Exception as e: - print(f'Error in {test.__name__}') - if verbose: - traceback.print_exc() - failed += 1 - else: - if verbose: - print('OK') - - total += 1 - - return failed, total - - -def run_doctests(tests, verbose=False): - runner = doctest.DocTestRunner() - for module, test_set in tests: - if test_set: - print(f"{module}...", end="" if not verbose else "\n", flush=True) - for test in test_set: - if verbose: - print("\tTesting:", test.name, flush=True) - runner.run(test) - print("OK") - - return runner.summarize() - - -def run_all_tests(tests=True, doctests=True, verbose=None): - - success = True - - if tests: - print("Running tests...") - t_failed, t_total = run_tests(verbose=verbose) - - if doctests: - print("Running doctests...") - d_failed, d_total = run_doctests(find_doctests(flint), verbose=verbose) - - if tests: - if t_failed: - print(f'flint.test: {t_failed} of {t_total} tests failed') - success = False - else: - print(f'flint.test: all {t_total} tests passed!') - - if doctests: - if d_failed: - print(f'flint.test: {d_failed} of {d_total} doctests failed') - success = False - else: - print(f'flint.test: all {d_total} doctests passed!') - - return success - - -def main(*args): - """Run the python-flint test-suite""" - - parser = argparse.ArgumentParser(description="Run the python-flint test-suite") - parser.add_argument("--quiet", "-q", action="store_true", help="less verbose output") - parser.add_argument("--verbose", "-v", action="store_true", help="more verbose output") - parser.add_argument("--tests", "-t", action="store_true", help="run tests") - parser.add_argument("--doctests", "-d", action="store_true", help="run doctests") - args = parser.parse_args(args) - - if not args.tests and not args.doctests: - # Default is run all tests: - tests = True - doctests = True - else: - # Either --tests or --doctests was specified - tests = args.tests - doctests = args.doctests - - # Default is show output from tests but keep the doctests quiet. - if args.verbose: - verbose = True - elif args.quiet: - verbose = False - else: - verbose = None - - success = run_all_tests(tests=tests, doctests=doctests, verbose=verbose) - - if not success: - print("----------------------------------------") - print("!!!FAILED!!!: Something is wrong with your installation of python-flint!") - print("----------------------------------------") - return 1 - else: - print("----------------------------------------") - print("OK: Your installation of python-flint seems to be working just fine!") - print("----------------------------------------") - return 0 - - -if __name__ == "__main__": - sys.exit(main(*sys.argv[1:])) diff --git a/src/flint/test/meson.build b/src/flint/test/meson.build deleted file mode 100644 index 1d2af323..00000000 --- a/src/flint/test/meson.build +++ /dev/null @@ -1,15 +0,0 @@ -thisdir = 'flint/test' - -pyfiles = [ - '__init__.py', - '__main__.py', - 'test_all.py', - 'test_arb.py', - 'test_docstrings.py', -] - -py.install_sources( - pyfiles, - pure: false, - subdir: thisdir, -) diff --git a/src/flint/test/test_all.py b/src/flint/test/test_all.py deleted file mode 100644 index d2f92a1f..00000000 --- a/src/flint/test/test_all.py +++ /dev/null @@ -1,5251 +0,0 @@ -from __future__ import annotations -from typing import Any, Callable, Sequence, TypeVar, Iterable, Protocol, TYPE_CHECKING - -import math -import operator -import pickle -import platform -import random - -import flint -import flint.typing as typ -import flint.flint_base.flint_base as flint_base -from flint.utils.flint_exceptions import DomainError, IncompatibleContextError - -from flint.test.test_arb import all_tests as arb_tests - - -PYPY = platform.python_implementation() == "PyPy" - -ctx = flint.ctx - -def raises(f, exception) -> bool: - try: - f() - except exception: - return True - return False - - -if TYPE_CHECKING: - from typing import TypeIs - - -Tscalar = TypeVar('Tscalar', bound=flint_base.flint_scalar) -Tscalar_co = TypeVar('Tscalar_co', bound=flint_base.flint_scalar, covariant=True) -Tmpoly = TypeVar('Tmpoly', bound=flint_base.flint_mpoly) -Tmpoly_p = TypeVar('Tmpoly_p', bound=typ.mpoly_p) -Tmpolyctx_co = TypeVar('Tmpolyctx_co', bound=flint_base.flint_mpoly_context, covariant=True) -Tmpolyctx_p_co = TypeVar('Tmpolyctx_p_co', bound=typ.mpoly_context_p, covariant=True) - - -_default_ctx_string = """\ -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\ -""" - -def test_pyflint(): - - assert flint.__version__ == "0.8.0" - - ctx = flint.ctx - assert str(ctx) == repr(ctx) == _default_ctx_string - assert ctx.prec == 53 - oldprec = ctx.prec - try: - f1 = flint.arb(2).sqrt() - ctx.prec = 10 - f2 = flint.arb(2).sqrt() - assert f1.rad() < f2.rad() - assert 1e-17 < f1.rad() < 1e-15 - assert 1e-3 < f2.rad() < 1e-2 - finally: - ctx.prec = oldprec - - assert ctx.dps == 15 - olddps = ctx.dps - try: - f1 = flint.arb(2).sqrt() - ctx.dps = 3 - f2 = flint.arb(2).sqrt() - assert f1.rad() < f2.rad() - assert 1e-17 < f1.rad() < 1e-15 - assert 1e-4 < f2.rad() < 1e-3 - finally: - ctx.dps = olddps - - assert ctx.cap == 10 - oldcap = ctx.cap - try: - f1 = flint.fmpz_series([1,1]) - ctx.cap = 5 - f2 = flint.fmpz_series([1,1]) - assert f1._equal_repr(flint.fmpz_series([1,1],10)) - assert f2._equal_repr(flint.fmpz_series([1,1],5)) - finally: - ctx.cap = oldcap - - assert raises(lambda: setattr(ctx, "cap", -1), ValueError) - assert raises(lambda: setattr(ctx, "prec", -1), ValueError) - assert raises(lambda: setattr(ctx, "dps", -1), ValueError) - - -def test_showgood(): - from flint import good, showgood - - -def test_fmpz(): - assert flint.fmpz() == flint.fmpz(0) - L = [0, 1, 2, 3, 2**31-1, 2**31, 2**63-1, 2**63, 2**64-1, 2**64] - L += [-x for x in L] - for i in L: - f = flint.fmpz(i) - assert int(f) == i - assert flint.fmpz(f) == f - assert flint.fmpz(str(i)) == f - assert raises(lambda: flint.fmpz(1,2), TypeError) # type: ignore - assert raises(lambda: flint.fmpz("qwe"), ValueError) - assert raises(lambda: flint.fmpz([]), TypeError) # type: ignore - for s in L: - for t in L: - for ltype in (flint.fmpz, int): - for rtype in (flint.fmpz, int): - - assert (ltype(s) == rtype(t)) == (s == t) - assert (ltype(s) != rtype(t)) == (s != t) - assert (ltype(s) < rtype(t)) == (s < t) - assert (ltype(s) <= rtype(t)) == (s <= t) - assert (ltype(s) > rtype(t)) == (s > t) - assert (ltype(s) >= rtype(t)) == (s >= t) - - assert ltype(s) + rtype(t) == s + t - assert ltype(s) - rtype(t) == s - t - assert ltype(s) * rtype(t) == s * t - assert ltype(s) & rtype(t) == s & t - assert ltype(s) | rtype(t) == s | t - assert ltype(s) ^ rtype(t) == s ^ t - assert ~ltype(s) == ~s - - if t == 0: - assert raises(lambda: ltype(s) // rtype(t), ZeroDivisionError) - assert raises(lambda: ltype(s) % rtype(t), ZeroDivisionError) - assert raises(lambda: divmod(ltype(s), rtype(t)), ZeroDivisionError) - else: - assert ltype(s) // rtype(t) == s // t - assert ltype(s) % rtype(t) == s % t - assert divmod(ltype(s), rtype(t)) == divmod(s, t) - - if 0 <= t < 10: - assert (ltype(s) ** rtype(t)) == (s ** t) - assert ltype(s) << rtype(t) == s << t - assert ltype(s) >> rtype(t) == s >> t - elif -10 <= t < 0: - assert raises(lambda: ltype(s) << rtype(t), ValueError) - assert raises(lambda: ltype(s) >> rtype(t), ValueError) - - assert 2 ** flint.fmpz(2) == 4 - assert type(2 ** flint.fmpz(2)) == flint.fmpz - assert raises(lambda: () ** flint.fmpz(1), TypeError) # type: ignore - assert raises(lambda: flint.fmpz(1) ** (), TypeError) # type: ignore - assert raises(lambda: flint.fmpz(1) ** -1, ValueError) - - mega = flint.fmpz(2) ** 8000000 - assert raises(lambda: mega ** mega, OverflowError) - - pow_mod_examples = [ - (2, 2, 3, 1), - (2, -1, 5, 3), - (2, 0, 5, 1), - (2, 5, 1000, 32), - ] - for a, b, c, ab_mod_c in pow_mod_examples: - assert pow(a, b, c) == ab_mod_c - assert pow(flint.fmpz(a), b, c) == ab_mod_c - assert pow(flint.fmpz(a), flint.fmpz(b), c) == ab_mod_c - assert pow(flint.fmpz(a), b, flint.fmpz(c)) == ab_mod_c - assert pow(flint.fmpz(a), flint.fmpz(b), flint.fmpz(c)) == ab_mod_c - - # 3-arg pow cannot be made to work with fmpz on PyPy - # https://github.com/flintlib/python-flint/issues/74 - if not PYPY: - # type checkers cannot understand 3-arg pow... - assert pow(a, flint.fmpz(b), c) == ab_mod_c # type: ignore - assert pow(a, b, flint.fmpz(c)) == ab_mod_c # type: ignore - assert pow(a, flint.fmpz(b), flint.fmpz(c)) == ab_mod_c # type: ignore - - assert raises(lambda: pow(flint.fmpz(2), 2, 0), ValueError) - # XXX: Handle negative modulus like int? - assert raises(lambda: pow(flint.fmpz(2), 2, -1), ValueError) - - assert raises(lambda: pow(flint.fmpz(2), "asd", 2), TypeError) # type: ignore - assert raises(lambda: pow(flint.fmpz(2), 2, "asd"), TypeError) # type: ignore - - f = flint.fmpz(2) - assert f.numerator == f - assert type(f.numerator) is flint.fmpz - assert f.denominator == 1 - assert type(f.denominator) is flint.fmpz - - assert int(f) == 2 - assert type(int(f)) is int - assert operator.index(f) == 2 - assert type(operator.index(f)) is int - assert float(f) == 2.0 - assert type(float(f)) is float - assert round(f) == 2 - assert type(round(f)) is flint.fmpz - assert round(f, 1) == 2 - assert type(round(f, 1)) is flint.fmpz - assert round(f, -1) == 0 - assert type(round(f, -1)) is flint.fmpz - assert math.trunc(f) == 2 - assert type(math.trunc(f)) is flint.fmpz - assert math.floor(f) == 2 - assert type(math.floor(f)) is flint.fmpz - assert math.ceil(f) == 2 - assert type(math.ceil(f)) is flint.fmpz - - assert flint.fmpz(2) != [] - assert +flint.fmpz(0) == 0 - assert +flint.fmpz(1) == 1 - assert +flint.fmpz(-1) == -1 - assert -flint.fmpz(0) == 0 - assert -flint.fmpz(1) == -1 - assert -flint.fmpz(-1) == 1 - assert abs(flint.fmpz(0)) == 0 - assert abs(flint.fmpz(1)) == 1 - assert abs(flint.fmpz(-1)) == 1 - - assert bool(flint.fmpz(0)) is False - assert bool(flint.fmpz(1)) is True - - assert flint.fmpz(2).bit_length() == 2 - assert flint.fmpz(-2).bit_length() == 2 - assert flint.fmpz(2).height_bits() == 2 - assert flint.fmpz(-2).height_bits() == 2 - assert flint.fmpz(2).height_bits(signed=True) == 2 - assert flint.fmpz(-2).height_bits(signed=True) == -2 - - f1 = flint.fmpz(1) - f2 = flint.fmpz(2) - f3 = flint.fmpz(3) - f8 = flint.fmpz(8) - - assert f2 << 2 == 8 - assert f2 << f2 == 8 - assert 2 << f2 == 8 - assert raises(lambda: f2 << -1, ValueError) - assert raises(lambda: 2 << -f1, ValueError) - - assert f8 >> 2 == f2 - assert f8 >> f2 == f2 - assert 8 >> f2 == f2 - assert raises(lambda: f2 >> -1, ValueError) - assert raises(lambda: 2 >> -f1, ValueError) - - assert f2 & 3 == 2 - assert f2 & f3 == 2 - assert 2 & f3 == 2 - assert f2 | 3 == 3 - assert f2 | f3 == 3 - assert 2 | f3 == 3 - assert f2 ^ 3 == 1 - assert f2 ^ f3 == 1 - assert 2 ^ f3 == 1 - - assert raises(lambda: f2 << (), TypeError) # type: ignore - assert raises(lambda: () << f2, TypeError) # type: ignore - assert raises(lambda: f2 >> (), TypeError) # type: ignore - assert raises(lambda: () >> f2, TypeError) # type: ignore - assert raises(lambda: f2 & (), TypeError) # type: ignore - assert raises(lambda: () & f2, TypeError) # type: ignore - assert raises(lambda: f2 | (), TypeError) # type: ignore - assert raises(lambda: () | f2, TypeError) # type: ignore - assert raises(lambda: f2 ^ (), TypeError) # type: ignore - assert raises(lambda: () ^ f2, TypeError) # type: ignore - - ell = [1, 2, 3] - ell[flint.fmpz(1)] = -2 - assert ell == [1, -2, 3] - d = {flint.fmpz(2): 3} - d[flint.fmpz(2)] = -1 - - assert d == {flint.fmpz(2): -1} - ctx.pretty = False - assert repr(flint.fmpz(0)) == "fmpz(0)" - assert repr(flint.fmpz(-27)) == "fmpz(-27)" - ctx.pretty = True - assert repr(flint.fmpz(0)) == "0" - assert repr(flint.fmpz(-27)) == "-27" - bigstr = '1' * 100 - big = flint.fmpz(bigstr) - assert big.str() == bigstr - assert big.str(condense=10) == '1111111111{...80 digits...}1111111111' - -def test_fmpz_factor(): - assert flint.fmpz(6).gcd(flint.fmpz(9)) == 3 - assert flint.fmpz(6).gcd(9) == 3 - assert raises(lambda: flint.fmpz(2).gcd('asd'), TypeError) # type: ignore - assert flint.fmpz(6).lcm(flint.fmpz(9)) == 18 - assert flint.fmpz(6).lcm(9) == 18 - assert raises(lambda: flint.fmpz(2).lcm('asd'), TypeError) # type: ignore - assert flint.fmpz(25).factor() == [(5, 2)] - n = flint.fmpz(10**100 + 1) - assert n.factor() == [ - (73, 1), (137, 1), (401, 1), (1201, 1), (1601, 1), (1676321, 1), (5964848081, 1), - (129694419029057750551385771184564274499075700947656757821537291527196801, 1)] - assert n.factor(trial_limit=100) == [ - (73, 1), (137, 1), (401, 1), - (2493516234411471571047384039650897753117456334167082044912715710972543643391271845384040149601, 1)] - assert n.factor_smooth() == [ - (73, 1), (137, 1), (401, 1), (1201, 1), (1601, 1), - (1296814508839693536173209832765271992846610925502473758289451540212712414540699659186801, 1)] - -def test_fmpz_functions(): - T, F, VE, OE, DE = True, False, ValueError, OverflowError, DomainError - cases = [ - # (f, [f(-1), f(0), f(1), f(2), ... f(10)]), - (lambda n: flint.fmpz(n).is_prime(), - [0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0]), - (lambda n: flint.fmpz(n).is_probable_prime(), - [0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0]), - (lambda n: flint.fmpz(n).is_perfect_power(), - [T, T, T, F, F, T, F, F, F, T, T, F]), - (lambda n: flint.fmpz(n).is_square(), - [F, T, T, F, F, T, F, F, F, F, T, F]), - (lambda n: flint.fmpz(n).partitions_p(), - [0, 1, 1, 2, 3, 5, 7, 11, 15, 22, 30, 42]), - (lambda n: flint.fmpz(n).moebius_mu(), - [1, 0, 1, -1, -1, 0, -1, 1, -1, 0, 0, 1]), - (lambda n: flint.fmpz.fac_ui(n), - [OE, 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]), - (lambda n: flint.fmpz.primorial_ui(n), - [OE, 1, 1, 2, 6, 6, 30, 30, 210, 210, 210, 210, 2310, 2310]), - (lambda n: flint.fmpz.fib_ui(n), - [OE, 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]), - (lambda n: flint.fmpz(n).rising(0), - [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), - (lambda n: flint.fmpz(n).rising(1), - [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), - (lambda n: flint.fmpz(n).rising(2), - [0, 0, 2, 6, 12, 20, 30, 42, 56, 72, 90, 110]), - (lambda n: flint.fmpz.bin_uiui(n, 0), - [OE, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]), - (lambda n: flint.fmpz.bin_uiui(n, 1), - [OE, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), - (lambda n: flint.fmpz.bin_uiui(n, 2), - [OE, 0, 0, 1, 3, 6, 10, 15, 21, 28, 36, 45]), - (lambda n: flint.fmpz.bell_number(n), - [OE, 1, 1, 2, 5, 15, 52, 203, 877, 4140, 21147, 115975]), - (lambda n: flint.fmpz.euler_number(n), - [OE, 1, 0, -1, 0, 5, 0, -61, 0, 1385, 0, -50521]), - (lambda n: flint.fmpz.stirling_s1(n, 1), - [OE, 0, 1, -1, 2, -6, 24, -120, 720, -5040, 40320, -362880]), - (lambda n: flint.fmpz.stirling_s2(n, 2), - [OE, 0, 0, 1, 3, 7, 15, 31, 63, 127, 255, 511]), - (lambda n: flint.fmpz(n).divisor_sigma(2), - [1, 0, 1, 5, 10, 21, 26, 50, 50, 85, 91, 130]), - (lambda n: flint.fmpz(n).euler_phi(), - [0, 0, 1, 1, 2, 2, 4, 2, 6, 4, 6, 4]), - (lambda n: flint.fmpz(n).isqrt(), - [DE, 0, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3]), - (lambda n: flint.fmpz(n).sqrtrem(), - [DE, (0, 0), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1)]), - (lambda n: flint.fmpz(n).sqrtmod(11), - [DE, 0, 1, DE, 5, 2, 4, DE, DE, DE, 3, DE]), - (lambda n: flint.fmpz(n).root(3), - [VE, 0, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2]), - (lambda n: flint.fmpz(n).jacobi(3), - [-1, 0, 1, -1, 0, 1, -1, 0, 1, -1, 0, 1]), - (lambda n: flint.fmpz(2).jacobi(n), - [1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1]), - ] - is_exception = lambda v: isinstance(v, type) and issubclass(v, Exception) - - for func, values in cases: - for n, val in enumerate(values, -1): - if is_exception(val): - assert raises(lambda: func(n), val) - else: - assert func(n) == val - - assert raises(lambda: flint.fmpz(1).root(-1), ValueError) - assert raises(lambda: flint.fmpz(1).jacobi('bad'), TypeError) # type: ignore - -def test_fmpz_poly(): - Z = flint.fmpz_poly - assert Z() == Z([]) - assert Z() == Z([0]) - assert Z() == Z([0,flint.fmpz(0),0]) - assert Z() == Z([0,0,0]) - assert Z() != Z([1]) - assert Z([1]) == Z([1]) - assert Z([1]) == Z([flint.fmpz(1)]) - assert Z(Z([1,2])) == Z([1,2]) - assert raises(lambda: Z([1,2,[]]), TypeError) # type: ignore - assert raises(lambda: Z({}), TypeError) # type: ignore - # XXX: This should probably be made to work: - assert raises(lambda: Z((1,2,3)), TypeError) # type: ignore - for ztype in [int, flint.fmpz]: - assert Z([1,2,3]) + ztype(5) == Z([6,2,3]) - assert ztype(5) + Z([1,2,3]) == Z([6,2,3]) - assert Z([1,2,3]) - ztype(5) == Z([-4,2,3]) - assert ztype(5) - Z([1,2,3]) == Z([4,-2,-3]) - assert Z([1,2,3]) * ztype(5) == Z([5,10,15]) - assert ztype(5) * Z([1,2,3]) == Z([5,10,15]) - assert Z([11,6,2]) // ztype(5) == Z([2,1]) - assert ztype(5) // Z([-2]) == Z([-3]) - assert ztype(5) // Z([1,2]) == 0 - assert Z([11,6,2]) % ztype(5) == Z([1,1,2]) - assert ztype(5) % Z([-2]) == Z([-1]) - assert ztype(5) % Z([1,2]) == 5 - assert Z([1,2,3]) ** ztype(0) == 1 - assert Z([1,2,3]) ** ztype(1) == Z([1,2,3]) - assert Z([1,2,3]) ** ztype(2) == Z([1,4,10,12,9]) - assert divmod(Z([11,6,2]), Z([1,2])) == (Z([2,1]), Z([9,1])) - assert raises(lambda: pow(Z([1,2]), 2, 3), NotImplementedError) # type: ignore - assert +Z([1,2]) == Z([1,2]) - assert -Z([1,2]) == Z([-1,-2]) - assert raises(lambda: Z([1,2]) + [], TypeError) # type: ignore - assert raises(lambda: Z([1,2]) - [], TypeError) # type: ignore - assert raises(lambda: Z([1,2]) * [], TypeError) # type: ignore - assert raises(lambda: Z([1,2]) / [], TypeError) # type: ignore - assert raises(lambda: Z([1,2]) // [], TypeError) # type: ignore - assert raises(lambda: Z([1,2]) % [], TypeError) # type: ignore - assert raises(lambda: divmod(Z([1,2]), []), TypeError) # type: ignore - assert raises(lambda: [] + Z([1,2]), TypeError) # type: ignore - assert raises(lambda: [] - Z([1,2]), TypeError) # type: ignore - assert raises(lambda: [] * Z([1,2]), TypeError) # type: ignore - assert raises(lambda: [] / Z([1,2]), TypeError) # type: ignore - assert raises(lambda: [] // Z([1,2]), TypeError) # type: ignore - assert raises(lambda: [] % Z([1,2]), TypeError) # type: ignore - assert raises(lambda: divmod([], Z([1,2])), TypeError) # type: ignore - assert raises(lambda: Z([1,2,3]) ** -1, DomainError) # type: ignore - assert raises(lambda: Z([1,2,3]) ** Z([1,2]), TypeError) # type: ignore - assert raises(lambda: Z([1,2]) // Z([]), ZeroDivisionError) - assert raises(lambda: Z([]) // Z([]), ZeroDivisionError) - assert raises(lambda: Z([1,2]) % Z([]), ZeroDivisionError) - assert raises(lambda: divmod(Z([1,2]), Z([])), ZeroDivisionError) - assert raises(lambda: Z([1,2]) < Z([1,2]), TypeError) # type: ignore - assert raises(lambda: Z([1,2]) < [], TypeError) # type: ignore - assert raises(lambda: [] < Z([1,2]), TypeError) # type: ignore - assert Z([]).degree() == -1 - assert Z([]).length() == 0 - p = Z([1,2]) - assert p.length() == 2 - assert p.degree() == 1 - assert p[0] == 1 - assert p[1] == 2 - assert p[2] == 0 - assert p[-1] == 0 - assert raises(lambda: p.__setitem__(-1, 1), ValueError) - p[0] = 3 - assert p[0] == 3 - p[4] = 7 - assert p.degree() == 4 - assert p[4] == 7 - assert p[3] == 0 - p[4] = 0 - assert p.degree() == 1 - assert p.coeffs() == [3,2] - assert Z([]).coeffs() == [] - assert bool(Z([])) is False - assert bool(Z([1])) is True - ctx.pretty = False - assert repr(Z([1,2])) == "fmpz_poly([1, 2])" - ctx.pretty = True - assert str(Z([1,2])) == "2*x + 1" - assert str(Z([])) == "0" - assert str(Z([1,0,2])) == "2*x^2 + 1" - assert str(Z([-1,0,2])) == "2*x^2 + (-1)" - assert str(Z([-1,0,1])) == "x^2 + (-1)" - p = Z([3,4,5]) - assert p(2) == 31 - assert p(flint.fmpq(2,3)) == flint.fmpq(71,9) - assert p(Z([1,-1])) == Z([12,-14,5]) - assert p(flint.fmpq_poly([2,3],5)) == flint.fmpq_poly([27,24,9],5) - assert p(flint.arb("1.1")).overlaps(flint.arb("13.45")) - assert p(flint.acb("1.1", "1.2")).overlaps(flint.acb("6.25", "18.00")) - assert raises(lambda: p(None), TypeError) # type: ignore - assert Z([1,2,3]).derivative() == Z([2,6]) - assert Z([1,2,-4]).height_bits() == 3 - assert Z([1,2,-4]).height_bits(signed=True) == -3 - assert Z([1,2,1]).sqrt() == Z([1,1]) - assert raises(lambda: Z([1,2,2]).sqrt(), DomainError) - assert Z([1,0,2,0,3]).deflation() == (Z([1,2,3]), 2) - assert Z([]).deflation() == (Z([]), 1) - assert Z([1,1]).deflation() == (Z([1,1]), 1) - [(r,m)] = Z([1,1]).complex_roots() - assert m == 1 - assert r.overlaps(-1) - assert Z([]).complex_roots() == [] - assert Z([1]).complex_roots() == [] - [(r,m)] = Z([1,1]).roots() - assert m == 1 - assert r == -1 - assert Z([]).roots() == [] - assert Z([1]).roots() == [] - assert Z([1, 2]).roots() == [] - -def test_fmpz_poly_factor(): - Z = flint.fmpz_poly - assert Z([1,2]).gcd(Z([3,4])) == 1 - assert Z([1,2,1]).gcd(Z([1,1])) == Z([1,1]) - assert raises(lambda: Z([1,2,1]).gcd([]), TypeError) # type: ignore - assert Z([1,2,1]).factor() == (1, [(Z([1,1]), 2)]) - -def test_fmpz_poly_functions(): - Z = flint.fmpz_poly - assert Z.cyclotomic(4) == Z([1,0,1]) - assert Z.cos_minpoly(10) == Z([-1,-1,1]) - assert Z.chebyshev_u(4) == Z([1,0,-12,0,16]) - assert Z.chebyshev_t(4) == Z([1,0,-8,0,8]) - assert Z.swinnerton_dyer(2) == Z([1,0,-10,0,1]) - assert Z.swinnerton_dyer(2, use_arb=False) == Z([1,0,-10,0,1]) - assert raises(lambda: Z.swinnerton_dyer(21), OverflowError) - assert Z.hilbert_class_poly(-7) == Z([3375,1]) - assert raises(lambda: Z.hilbert_class_poly(-2), ValueError) - assert Z([1]).is_cyclotomic() == 0 - assert Z([-1,1]).is_cyclotomic() == 1 - assert Z([1,1]).is_cyclotomic() == 2 - assert Z([1,2]).is_cyclotomic() == 0 - assert Z([1,2,1]).is_cyclotomic() == 0 - assert Z([2,2,1,1]).is_cyclotomic() == 0 - assert Z([2,2,1]).is_cyclotomic() == 0 - assert Z([1,2,2]).is_cyclotomic() == 0 - assert Z([1,1,1]).is_cyclotomic() == 3 - -def test_fmpz_mat(): - M = flint.fmpz_mat - a = M(2,3,[1,2,3,4,5,6]) - b = M(2,3,[4,5,6,7,8,9]) - assert a == a - assert a == M(a) - assert a != b - assert a.nrows() == 2 - assert a.ncols() == 3 - assert a.entries() == [1,2,3,4,5,6] - assert a.table() == [[1,2,3],[4,5,6]] - assert (a + b).entries() == [5,7,9,11,13,15] - assert (a - b).entries() == [-3,-3,-3,-3,-3,-3] - assert a.transpose() == M(3,2,[1,4,2,5,3,6]) - assert raises(lambda: a + 1, TypeError) - assert raises(lambda: 1 + a, TypeError) - assert raises(lambda: a - 1, TypeError) - assert raises(lambda: 1 - a, TypeError) - # XXX: Maybe there should be a ShapeError or something? - assert raises(a.det, ValueError) - assert +a == a - assert -a == M(2,3,[-1,-2,-3,-4,-5,-6]) - c = M(2,2,[1,2,3,4]) - assert c.det() == -2 - assert raises(lambda: a + c, ValueError) - assert (a * 3).entries() == [3,6,9,12,15,18] - assert (3 * a).entries() == [3,6,9,12,15,18] - assert (a * flint.fmpz(3)).entries() == [3,6,9,12,15,18] - assert (flint.fmpz(3) * a).entries() == [3,6,9,12,15,18] - assert M.randrank(5,7,3,10).rank() == 3 - A = M.randbits(5,3,2) - B = M.randtest(3,7,3) - C = M.randtest(7,2,4) - assert (A.nrows(),A.ncols()) == (5,3) - assert (B.nrows(),B.ncols()) == (3,7) - assert (C.nrows(),C.ncols()) == (7,2) - assert A*(B*C) == (A*B)*C - assert raises(lambda: A*C, ValueError) - assert bool(M(2,2,[0,0,0,0])) is False - assert bool(M(2,2,[0,0,0,1])) is True - ctx.pretty = False - assert repr(M(2,2,[1,2,3,4])) == 'fmpz_mat(2, 2, [1, 2, 3, 4])' - ctx.pretty = True - assert str(M(2,2,[1,2,3,4])) == '[1, 2]\n[3, 4]' - assert M(1,2,[3,4]) * flint.fmpq(1,3) == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)]) - assert flint.fmpq(1,3) * M(1,2,[3,4]) == flint.fmpq_mat(1, 2, [1, flint.fmpq(4,3)]) - assert raises(lambda: M(1,2,[3,4]) / 3, DomainError) - assert M(1,2,[2,4]) / 2 == M(1,2,[1,2]) - assert M(2,2,[1,2,3,4]).inv().det() == flint.fmpq(1) / M(2,2,[1,2,3,4]).det() - assert M(2,2,[1,2,3,4]).inv().inv() == M(2,2,[1,2,3,4]) - assert raises(lambda: M.randrank(4,3,4,1), ValueError) - assert raises(lambda: M.randrank(3,4,4,1), ValueError) - assert M(1,1,[3]) ** 5 == M(1,1,[3**5]) - assert raises(lambda: pow(M([[1]]), 2, 3), NotImplementedError) - assert raises(lambda: M(1,2) ** 3, ValueError) - assert raises(lambda: M(1,1) ** M(1,1), TypeError) - assert raises(lambda: 1 ** M(1,1), TypeError) - assert raises(lambda: M([1]), TypeError) - assert raises(lambda: M([[1],[2,3]]), ValueError) - assert raises(lambda: M(None), TypeError) - assert raises(lambda: M(2,2,[1,2,3]), ValueError) - assert raises(lambda: M(2,2,2,2), TypeError) - assert M([[1,2,3],[4,5,6]]) == M(2,3,[1,2,3,4,5,6]) - assert raises(lambda: M([[1]]) < M([[2]]), TypeError) - assert (M([[1]]) == 1) is False - assert (1 == M([[1]])) is False - assert (M([[1]]) != 1) is True - assert (1 != M([[1]])) is True - D = M([[1,2],[3,4]]) - assert (D[0,0],D[0,1],D[1,0],D[1,1]) == (1,2,3,4) - D[0,0] = 3 - assert D == M([[3,2],[3,4]]) - - def set_bad(i,j): - D[i,j] = -1 - - # XXX: Should be IndexError - raises(lambda: set_bad(2,0), IndexError) - raises(lambda: set_bad(0,2), IndexError) - raises(lambda: D[0,2], IndexError) - raises(lambda: D[0,2], IndexError) - # XXX: Negative indices? - raises(lambda: set_bad(-1,0), IndexError) - raises(lambda: set_bad(0,-1), IndexError) - raises(lambda: D[-1,0], IndexError) - raises(lambda: D[0,-1], IndexError) - assert M.hadamard(2) == M([[1,1],[1,-1]]) - assert raises(lambda: M.hadamard(3), ValueError) - assert M.hadamard(2).is_hadamard() is True - assert M([[1,2],[3,4]]).is_hadamard() is False - M1 = M([[1,0],[1,1]]) - M2 = M([[1,0],[-1,1]]) - x = M([[3],[4]]) - b = M([[3],[7]]) - assert M1.inv() == M2 - assert M2.inv() == M1 - assert M1.inv(integer=True) == M2 - assert M2.inv(integer=True) == M1 - assert M1*x == b - assert M1.solve(b) == x - assert M1.solve(b, integer=True) == x - assert raises(lambda: M1.solve([]), TypeError) - assert raises(lambda: M1.solve(M([[1]])), ValueError) - assert raises(lambda: M([[1,1],[1,1]]).solve(b), ZeroDivisionError) - assert raises(lambda: M([[1,2],[3,4],[5,6]]).solve(b), ValueError) - assert M([[1,0],[1,2]]).solve(b) == flint.fmpq_mat([[3],[2]]) - assert raises(lambda: M([[1,0],[1,2]]).solve(b, integer=True), ValueError) - assert raises(lambda: M([[1,2,3],[4,5,6]]).inv(), ValueError) - assert raises(lambda: M([[1,1],[1,1]]).inv(), ZeroDivisionError) - assert raises(lambda: M([[1,0],[1,2]]).inv(integer=True), ValueError) - half = flint.fmpq(1,2) - assert M([[1,0],[1,2]]).inv() == flint.fmpq_mat([[1, 0], [-half, half]]) - M3 = M([[1,2,3],[4,5,6],[7,8,9]]) - M3_copy = M(M3) - M3r = M([[-3,0,3],[0,-3,-6],[0,0,0]]) - assert M3.rref() == (M3r, -3, 2) - assert M3 != M3r - assert M3.rref(inplace=True) == (M3r, -3, 2) - assert M3 == M3r - M3 = M3_copy - M3n = M([[3,0,0],[-6,0,0],[3,0,0]]) - assert M3.nullspace() == (M3n, 1) - assert M3 * M3.nullspace()[0] == M(3,3,[0]*9) - M4 = M([[1,2,3],[4,5,6],[7,8,10]]) - L4 = M([[0,0,1],[-1,1,0],[2,1,0]]) - T4 = M([[1,-2,1],[0,5,-3],[-2,1,0]]) - assert L4 == T4 * M4 - assert M4.lll() == L4 - assert M4.lll(transform=True) == (L4, T4) - M5 = M([[1,2,3],[4,5,6],[7,8,9]]) - L5 = M([[0,0,0],[2,1,0],[-1,1,3]]) - T5 = M([[1,-2,1],[-2,1,0],[3,-1,0]]) - assert L5 == T5 * M5 - assert M5.lll() == L5 - assert M5.lll(transform=True) == (L5, T5) - Mz = M(0, 3, []) - assert Mz.lll() == M(0, 3, []) - assert Mz.lll(transform=True) == (M(0, 3, []), M(0, 0, [])) - Mr = M(3, 0, []) - assert Mr.lll() == M(3, 0, []) - assert Mr.lll(transform=True) == (M(3, 0, []), M([[1,0,0],[0,1,0],[0,0,1]])) - Mzz = M(0, 0, []) - assert Mzz.lll() == M(0, 0, []) - assert Mzz.lll(transform=True) == (M(0, 0, []), M(0, 0, [])) - # XXX: rep="gram" consumes all memory in the system and core dumps - #for rep in "zbasis", "gram": - rep = "zbasis" - for gram in "approx", "exact": - assert M4.lll(rep=rep, gram=gram) == L4 - assert M4.lll(rep=rep, gram=gram, transform=True) == (L4, T4) - assert raises(lambda: M4.lll(rep="bad"), ValueError) - assert raises(lambda: M4.lll(gram="bad"), ValueError) - M5 = M([[1,2,3],[4,5,6]]) - H5 = M([[1,2,3],[0,3,6]]) - T5 = M([[1,0],[4,-1]]) - assert H5 == T5 * M5 - assert M5.hnf() == H5 - assert M5.hnf(transform=True) == (H5, T5) - assert M5.is_hnf() is False - assert H5.is_hnf() is True - S5 = M([[1,0,0],[0,3,0]]) - assert M5.snf() == S5 - assert M5.is_snf() is False - assert S5.is_snf() is True - M6 = M([[2,0,0],[0,2,1],[0,0,2]]) - assert M6.charpoly() == flint.fmpz_poly([-8,12,-6,1]) - assert M6.minpoly() == flint.fmpz_poly([4,-4,1]) - assert list(M6) == [2,0,0,0,2,1,0,0,2] - - -def test_fmpz_series(): - Zp = flint.fmpz_poly - Z = flint.fmpz_series - ctx = flint.ctx - assert ctx.cap == 10 - s1 = Z([1,2]) - s2 = Z([1,2]) - s3 = Z([1,1]) - s4 = Z([1,2],11) - s5 = Z([1,2],3) - p1 = Zp([1,2]) - assert s1.prec == 10 - assert s4.prec == 11 - assert s5.prec == 3 - assert s1._equal_repr(s1) is True - assert s1._equal_repr(s2) is True - assert s1._equal_repr(s3) is False - assert s1._equal_repr(s4) is False - assert s1._equal_repr(p1) is False - assert s1._equal_repr(flint.fmpz(1)) is False - assert s1._equal_repr(1) is False - assert Z([])._equal_repr(Z([0])) is True - assert Z([1])._equal_repr(Z([0])) is False - p = Z([1,2]) - assert p.prec == 10 - p4 = Z([1,2], prec=4) - assert p4.prec == 4 - p4 = Z(p, prec=4) - assert p4.prec == 4 - # XXX: this gives a core dump: - # s = Z([1,2]) - # s[10**10] = 1 - assert Z(Z([1]))._equal_repr(Z([1])) - assert Z(Zp([1]))._equal_repr(Z([1])) - assert Z(1)._equal_repr(Z([1])) - assert raises(lambda: Z([1]) < Z([1]), TypeError) # type: ignore - assert len(Z([1,2])) == 2 - assert Z([1,2]).length() == 2 - s5 = Z([1,2]) - assert s5[1] == 2 - assert s5[2] == 0 - assert s5[-1] == 0 - # XXX: This goes beyond cap. Should it give an error? - assert s5[100] == 0 - s5[2] = -1 - assert s5[2] == -1 - assert s5._equal_repr(Z([1,2,-1])) - - def set_bad(): - s5[-1] = 3 - - assert raises(set_bad, ValueError) - assert Z([1,2,0,4]).str() == "1 + 2*x + 4*x^3 + O(x^10)" - assert Z([1,2,0,4]).repr() == "fmpz_series([1, 2, 0, 4], prec=10)" - assert Z([],0).str() == "O(x^0)" - assert Z([],-1).str() == "(invalid power series)" - assert (+Z([1,2]))._equal_repr(Z([1,2])) - assert (-Z([1,2]))._equal_repr(Z([-1,-2])) - assert (Z([1,2]) + Z([3,4,5]))._equal_repr(Z([4,6,5])) - assert (Z([1,2]) + 1)._equal_repr(Z([2,2])) - assert (Z([1,2]) + Zp([3,4,5]))._equal_repr(Z([4,6,5])) - assert (1 + Z([1,2]))._equal_repr(Z([2,2])) - assert (Zp([1,2]) + Z([3,4,5]))._equal_repr(Z([4,6,5])) - assert raises(lambda: Z([1,2]) + [], TypeError) # type: ignore - assert raises(lambda: [] + Z([1,2]), TypeError) # type: ignore - assert (Z([1,2]) - Z([3,5]))._equal_repr(Z([-2,-3])) - assert (Z([1,2]) - 1)._equal_repr(Z([0,2])) - assert (1 - Z([1,2]))._equal_repr(Z([0,-2])) - assert raises(lambda: [] - Z([1,2]), TypeError) # type: ignore - assert raises(lambda: Z([1,2]) - [], TypeError) # type: ignore - assert (Z([1,2]) * Z([1,2]))._equal_repr(Z([1,4,4])) - assert (2 * Z([1,2]))._equal_repr(Z([2,4])) - assert (Z([1,2]) * 2)._equal_repr(Z([2,4])) - assert raises(lambda: [] * Z([1,2]), TypeError) # type: ignore - assert raises(lambda: Z([1,2]) * [], TypeError) # type: ignore - assert Z([1,2]).valuation() == 0 - assert Z([0,2]).valuation() == 1 - assert Z([0,0]).valuation() == -1 - assert (Z([1,1]) / Z([1,-1]))._equal_repr(Z([1,2,2,2,2,2,2,2,2,2])) - assert raises(lambda: Z([1,1]) / Z([]), ZeroDivisionError) - assert (Z([]) / Z([1,-1]))._equal_repr(Z([])) - # quotient would not be a power series - assert raises(lambda: Z([1,1]) / Z([0,1]), ValueError) - # leading term in denominator is not a unit - assert raises(lambda: Z([1,1]) / Z([2,1]), ValueError) - assert (Z([0,1,1]) / Z([0,1,-1]))._equal_repr(Z([1,2,2,2,2,2,2,2,2],9)) - # XXX: This gives leading term not a unit: - # assert Z([2,4]) / 2 == Z([1,2]) - assert (Z([1,1]) / -1)._equal_repr(Z([-1,-1])) - assert raises(lambda: Z([1,1]) / [], TypeError) # type: ignore - assert raises(lambda: [] / Z([1,1]), TypeError) # type: ignore - assert (Z([1,2]) ** 2)._equal_repr(Z([1,4,4])) - assert raises(lambda: pow(Z([1,2]), 3, 5), NotImplementedError) # type: ignore - assert (Z([1,2])(Z([0,1,2])))._equal_repr(Z([1,2,4])) - assert raises(lambda: Z([1,2])(Z([1,2])), ValueError) - assert raises(lambda: Z([1,2])([]), TypeError) # type: ignore - coeffs = [0, 1, -2, 8, -40, 224, -1344, 8448, -54912, 366080] - assert Z([0,1,2]).reversion()._equal_repr(Z(coeffs)) - # power series reversion must have valuation 1 - assert raises(lambda: Z([1,1]).reversion(), ValueError) - # leading term is not a unit - assert raises(lambda: Z([0,2,1]).reversion(), ValueError) - - -def test_fmpq() -> None: - Q = flint.fmpq - assert Q() == Q(0) - assert Q(0) != Q(1) - assert Q(0) == 0 - assert 0 == Q(0) - assert Q(2) != 1 - assert 1 != Q(2) - assert Q(1) != () - assert Q(1,2) != 1 - assert Q(2,3) == Q(flint.fmpz(2),3) - assert Q(-2,-4) == Q(1,2) - assert Q("1") == Q(1) - assert Q("1/2") == Q(1,2) - assert Q(Q(1,2),Q(3,4)) == Q(2,3) - assert Q(1,Q(2,3)) == Q(3,2) - assert Q(Q(1,2),3) == Q(1,6) - assert Q(flint.fmpz(1),Q(2,3)) == Q(3,2) - assert Q(Q(1,2),flint.fmpz(3)) == Q(1,6) - assert raises(lambda: Q("1.0"), ValueError) - assert raises(lambda: Q("1.5"), ValueError) - assert raises(lambda: Q("1/2/3"), ValueError) - assert raises(lambda: Q([]), TypeError) # type: ignore - assert raises(lambda: Q(1, []), TypeError) # type: ignore - assert raises(lambda: Q([], 1), TypeError) # type: ignore - assert bool(Q(0)) is False - assert bool(Q(1)) is True - assert Q(1,3) + Q(2,3) == 1 - assert Q(1,3) - Q(2,3) == Q(-1,3) - assert Q(1,3) * Q(2,3) == Q(2,9) - assert Q(1,3) + 2 == Q(7,3) - assert 2 + Q(1,3) == Q(7,3) - assert Q(1,3) - 2 == Q(-5,3) - assert 2 - Q(1,3) == Q(5,3) - assert Q(1,3) * 2 == Q(2,3) - assert 2 * Q(1,3) == Q(2,3) - assert Q(2,3) / Q(4,5) == Q(5,6) - assert Q(2,3) / 5 == Q(2,15) - assert Q(2,3) / flint.fmpz(5) == Q(2,15) - assert 5 / Q(2,3) == Q(15,2) - assert flint.fmpz(5) / Q(2,3) == Q(15,2) - assert Q(2,3)/5 == Q(2,15) - assert Q(1,2) ** 2 == Q(1,4) - assert Q(1,2) ** -2 == Q(4) - assert raises(lambda: Q(0) ** -1, ZeroDivisionError) - assert raises(lambda: Q(1,2) ** Q(1,2), TypeError) # type: ignore - assert raises(lambda: Q(1,2) ** [], TypeError) # type: ignore - assert raises(lambda: [] ** Q(1,2), TypeError) # type: ignore - assert raises(lambda: pow(Q(1,2),2,3), TypeError) # type: ignore - - megaz = flint.fmpz(2) ** 8000000 - megaq = Q(megaz) - assert raises(lambda: megaq ** megaz, OverflowError) - - assert raises(lambda: Q(1,2) + [], TypeError) # type: ignore - assert raises(lambda: Q(1,2) - [], TypeError) # type: ignore - assert raises(lambda: Q(1,2) * [], TypeError) # type: ignore - assert raises(lambda: Q(1,2) / [], TypeError) # type: ignore - assert raises(lambda: [] + Q(1,2), TypeError) # type: ignore - assert raises(lambda: [] - Q(1,2), TypeError) # type: ignore - assert raises(lambda: [] * Q(1,2), TypeError) # type: ignore - assert raises(lambda: [] / Q(1,2), TypeError) # type: ignore - assert (Q(1,2) == 1) is False - assert (Q(1,2) != 1) is True - assert (Q(1,2) < 1) is True - assert (Q(1,2) <= 1) is True - assert (Q(1,2) > 1) is False - assert (Q(1,2) >= 1) is False - assert (Q(1,2) == Q(3,4)) is False - assert (Q(1,2) != Q(3,4)) is True - assert (Q(1,2) < Q(3,4)) is True - assert (Q(1,2) <= Q(3,4)) is True - assert (Q(1,2) > Q(3,4)) is False - assert (Q(1,2) >= Q(3,4)) is False - assert (Q(1,2) == Q(1,2)) is True - assert (Q(1,2) != Q(1,2)) is False - assert (Q(1,2) < Q(1,2)) is False - assert (Q(1,2) <= Q(1,2)) is True - assert (Q(1,2) > Q(1,2)) is False - assert (Q(1,2) >= Q(1,2)) is True - assert raises(lambda: Q(1,2) > [], TypeError) # type: ignore - assert raises(lambda: [] < Q(1,2), TypeError) # type: ignore - - ctx.pretty = False - assert repr(Q(-2,3)) == "fmpq(-2,3)" - assert repr(Q(3)) == "fmpq(3)" - ctx.pretty = True - assert str(Q(-2,3)) == "-2/3" - assert str(Q(3)) == "3" - - assert Q(2,3).p == Q(2,3).numer() == Q(2,3).numerator == 2 - assert Q(2,3).q == Q(2,3).denom() == Q(2,3).denominator == 3 - assert +Q(5,7) == Q(5,7) - assert -Q(5,7) == Q(-5,7) - assert -Q(-5,7) == Q(5,7) - assert abs(Q(5,7)) == Q(5,7) - assert abs(-Q(5,7)) == Q(5,7) - assert raises(lambda: Q(1,0), ZeroDivisionError) - assert raises(lambda: Q(1,2) / Q(0), ZeroDivisionError) - assert raises(lambda: Q(1,2) / 0, ZeroDivisionError) - - assert Q(2,3).gcd(Q(4,9)) == Q(2,9) - assert Q(2,3).gcd(5) == Q(1,3) - assert raises(lambda: Q(2,3).gcd([]), TypeError) # type: ignore - - assert Q(5,3).floor() == flint.fmpz(1) - assert Q(-5,3).floor() == flint.fmpz(-2) - assert Q(5,3).ceil() == flint.fmpz(2) - assert Q(-5,3).ceil() == flint.fmpz(-1) - - assert type(int(Q(5,3))) is int - assert type(float(Q(5,3))) is float - assert type(complex(Q(5,3))) is complex - assert type(math.floor(Q(5,3))) is flint.fmpz - assert type(math.ceil(Q(5,3))) is flint.fmpz - assert type(math.trunc(Q(5,3))) is flint.fmpz - assert type(round(Q(5,3))) is flint.fmpz - assert type(round(Q(5,3))) is flint.fmpz - assert type(round(Q(5,3), 0)) is flint.fmpq - assert type(round(Q(5,3), 1)) is flint.fmpq - - assert int(Q(5,3)) == 1 - assert float(Q(5,3)) == 5/3 - assert complex(Q(5,3)) == 5/3 + 0j - assert math.floor(Q(5,3)) == flint.fmpz(1) - assert math.ceil(Q(5,3)) == flint.fmpz(2) - assert math.trunc(Q(5,3)) == flint.fmpz(1) - assert round(Q(5,3)) == flint.fmpz(2) - - assert int(Q(-5,3)) == flint.fmpz(-1) - assert math.floor(Q(-5,3)) == flint.fmpz(-2) - assert math.ceil(Q(-5,3)) == flint.fmpz(-1) - assert math.trunc(Q(-5,3)) == flint.fmpz(-1) - assert round(Q(-5,3)) == -2 - - assert round(Q(100,3), 2) == Q(3333,100) - assert round(Q(100,3), 0) == Q(33,1) - assert round(Q(100,3), -1) == Q(30,1) - assert round(Q(100,3), -2) == Q(0) - - d = {} - d[Q(1,2)] = 3 - d[Q(1,2)] = 4 - assert d == {Q(1,2):4} - - assert Q(-5,3).height_bits() == 3 - assert Q(-5,3).height_bits(signed=True) == -3 - - cases1: list[tuple[Callable[[flint.fmpq], flint.fmpq], list[flint.fmpq]]] = [ - (lambda q: q.next(), - [Q(0), Q(1), Q(-1), Q(1,2), Q(-1,2), Q(2), Q(-2), Q(1,3), Q(-1,3), Q(3)]), - (lambda q: q.next(signed=False), - [Q(0), Q(1), Q(1,2), Q(2), Q(1,3), Q(3), Q(2,3), Q(3,2), Q(1,4), Q(4)]), - (lambda q: q.next(minimal=False), - [Q(0), Q(1), Q(-1), Q(1,2), Q(-1,2), Q(2), Q(-2), Q(1,3), Q(-1,3), Q(3,2)]), - (lambda q: q.next(signed=False, minimal=False), - [Q(0), Q(1), Q(1,2), Q(2), Q(1,3), Q(3,2), Q(2,3), Q(3), Q(1,4), Q(4,3)]), - ] - for func, values in cases1: - for val1, val2 in zip(values[:-1], values[1:]): - assert func(val1) == val2 - raises(lambda: Q(-1).next(signed=False), ValueError) - - OE = OverflowError - cases2: list[tuple[Callable[[int], flint.fmpq], list[flint.fmpq | type[OverflowError]]]] = [ - (flint.fmpq.bernoulli, - [OE, Q(1), Q(-1,2), Q(1,6), Q(0), Q(-1,30)]), - (lambda n: flint.fmpq.bernoulli(n, cache=True), - [OE, Q(1), Q(-1,2), Q(1,6), Q(0), Q(-1,30)]), - (flint.fmpq.harmonic, - [OE, Q(0), Q(1), Q(3,2), Q(11, 6), Q(25, 12)]), - (lambda n: flint.fmpq.dedekind_sum(n, 3), - [-Q(1,18), Q(0), Q(1,18), -Q(1,18), Q(0), Q(1,18), -Q(1,18)]), - ] - is_exception = lambda v: isinstance(v, type) and issubclass(v, Exception) - - for func2, values2 in cases2: - for n, val in enumerate(values2, -1): - if is_exception(val): - assert raises(lambda: func2(n), val) - else: - assert func2(n) == val - -def test_fmpq_poly(): - Q = flint.fmpq_poly - Z = flint.fmpz_poly - assert Q() == Q([]) == Q([0]) == Q([0,0]) - assert Q() != Q([1]) - assert Q([1]) == Q([1]) - assert Q([1], 2) == Q([flint.fmpq(1,2)]) - assert raises(lambda: Q([1,[]]), TypeError) # type: ignore - assert raises(lambda: Q({}), TypeError) # type: ignore - assert raises(lambda: Q([1], []), TypeError) # type: ignore - assert raises(lambda: Q([1], 0), ZeroDivisionError) - assert bool(Q()) is False - assert bool(Q([1])) is True - assert Q(Q([1,2])) == Q([1,2]) - assert Q(Z([1,2])) == Q([1,2]) - assert Q([1,2]) + 3 == Q([4,2]) - assert 3 + Q([1,2]) == Q([4,2]) - assert Q([1,2]) - 3 == Q([-2,2]) - assert 3 - Q([1,2]) == Q([2,-2]) - assert raises(lambda: Q([1]) + [], TypeError) # type: ignore - assert raises(lambda: [] + Q([1]), TypeError) # type: ignore - assert raises(lambda: Q([1]) - [], TypeError) # type: ignore - assert raises(lambda: [] - Q([1]), TypeError) # type: ignore - assert raises(lambda: Q([1]) * [], TypeError) # type: ignore - assert raises(lambda: [] * Q([1]), TypeError) # type: ignore - assert Q([1,2,1]) // Q([1,1]) == Q([1,1]) - assert Q([1,2,1]) % Q([1,1]) == 0 - assert divmod(Q([1,2,1]), Q([1,1])) == (Q([1,1]), 0) - assert raises(lambda: Q([1,2,1]) // [], TypeError) # type: ignore - assert raises(lambda: [] // Q([1,2,1]), TypeError) # type: ignore - assert raises(lambda: Q([1,2,1]) % [], TypeError) # type: ignore - assert raises(lambda: [] % Q([1,2,1]), TypeError) # type: ignore - assert raises(lambda: divmod(Q([1,2,1]), []), TypeError) # type: ignore - assert raises(lambda: divmod([], Q([1,2,1])), TypeError) # type: ignore - assert raises(lambda: Q([1,2,1]) / 0, ZeroDivisionError) - assert raises(lambda: Q([1,2,1]) // 0, ZeroDivisionError) - assert raises(lambda: Q([1,2,1]) % 0, ZeroDivisionError) - assert raises(lambda: divmod(Q([1,2,1]), 0), ZeroDivisionError) - assert +Q([1,2]) == Q([1,2]) - assert -Q([1,2]) == Q([-1,-2]) - assert Q([flint.fmpq(1,2),1]) * 2 == Q([1,2]) - assert Q([1,2]) == Z([1,2]) - assert Z([1,2]) == Q([1,2]) - assert Q([1,2]) != Z([3,2]) - assert Z([1,2]) != Q([3,2]) - assert Q([1,2]) != [] - assert raises(lambda: Q([1,2]) < Q([1,2]), TypeError) # type: ignore - assert Q([1,2,3])*Q([1,2]) == Q([1,4,7,6]) - assert Q([1,2,3])*Z([1,2]) == Q([1,4,7,6]) - assert Q([1,2,3]) * 3 == Q([3,6,9]) - assert 3 * Q([1,2,3]) == Q([3,6,9]) - assert Q([1,2,3]) * flint.fmpq(2,3) == (Q([1,2,3]) * 2) / 3 - assert flint.fmpq(2,3) * Q([1,2,3]) == (Q([1,2,3]) * 2) / 3 - assert Q([1,2]) / Q([1,2]) == Q([1]) - assert raises(lambda: Q([1,2]) / Q([2,2]), DomainError) - assert Q([1,2,3]) / flint.fmpq(2,3) == Q([1,2,3]) * flint.fmpq(3,2) - assert Q([1,2,3]) ** 2 == Q([1,2,3]) * Q([1,2,3]) - assert raises(lambda: pow(Q([1,2]), 3, 5), NotImplementedError) # type: ignore - assert Q([1,2,flint.fmpq(1,2)]).coeffs() == [1,2,flint.fmpq(1,2)] - assert Q().coeffs() == [] - assert Q().degree() == -1 - assert Q([1]).degree() == 0 - assert Q([1,2]).degree() == 1 - assert Q().length() == 0 - assert Q([1]).length() == 1 - assert Q([1,2]).length() == 2 - assert (Q([1,2,3]) / 5).numer() == (Q([1,2,3]) / 5).p == Z([1,2,3]) - assert (Q([1,2,3]) / 5).denom() == (Q([1,2,3]) / 5).q == 5 - ctx.pretty = False - assert repr(Q([15,20,10])) == "fmpq_poly([15, 20, 10])" - assert repr(Q([15,20,10]) / 25) == "fmpq_poly([3, 4, 2], 5)" - ctx.pretty = True - assert str(Q([3,4,2],5)) == "2/5*x^2 + 4/5*x + 3/5" - a = Q([2,2,3],4) - assert a[2] == flint.fmpq(3,4) - assert a[-1] == flint.fmpq(0) - a[2] = 4 - - def set_bad(): - a[-1] = 2 - - assert raises(set_bad, ValueError) - assert a == Q([1,1,8],2) - p = Q([3,4,5],7) - assert p(2) == flint.fmpq(31,7) - assert p(flint.fmpq(2,3)) == flint.fmpq(71,63) - assert p(Z([1,-1])) == Q([12,-14,5],7) - assert p(flint.fmpq_poly([2,3],5)) == flint.fmpq_poly([27,24,9],7*5) - assert raises(lambda: p([]), TypeError) # type: ignore - assert Q([1,2,3]).derivative() == Q([2,6]) - assert Q([1,2,3]).integral() == Q([0,1,1,1]) - assert Q([1,2,1]).gcd(Q([1,1])) == Q([1,1]) - assert Q([1,2,1]).xgcd(Q([1,1])) == (Q([1,1]), 0, 1) - assert raises(lambda: Q([1,2,1]).gcd([]), TypeError) # type: ignore - assert raises(lambda: Q([1,2,1]).xgcd([]), TypeError) # type: ignore - assert Q([1,2,1]).factor() == (1, [(Q([1,1]), 2)]) - assert Q.bernoulli_poly(3) == Q([0,1,-3,2],2) - assert Q.euler_poly(3) == Q([1,0,-6,4],4) - assert Q.legendre_p(3) == Q([0,-3,0,5],2) - assert Q([]).complex_roots() == [] - assert Q([1]).complex_roots() == [] - [(r,m)] = Q([1,1]).complex_roots() - assert m == 1 - assert r.overlaps(-1) - assert str(Q([1,2]).roots()) == "[(-1/2, 1)]" - assert Q([2,1]).roots() == [(-2, 1)] - -def test_fmpq_mat(): - Q = flint.fmpq_mat - Z = flint.fmpz_mat - assert Q(1,2,[3,4]) == Z(1,2,[3,4]) - assert Q(1,2,[3,4]) != Z(1,2,[5,4]) - assert Q(1,2,[3,4]) != Q(1,2,[5,4]) - assert Q(Q(1,2,[3,4])) == Q(1,2,[3,4]) - assert Q(Z(1,2,[3,4])) == Q(1,2,[3,4]) - assert Q(2,3,[1,2,3,4,5,6]) + Q(2,3,[4,5,6,7,8,9]) == Q(2,3,[5,7,9,11,13,15]) - assert Q(2,3,[1,2,3,4,5,6]) - Q(2,3,[4,5,6,7,8,9]) == Q(2,3,[-3,-3,-3,-3,-3,-3]) - assert Q(2,3,[1,2,3,4,5,6]) * Q(3,2,[4,5,6,7,8,9]) == Q(2,2,[40,46,94,109]) - assert Q(2,3,[1,2,3,4,5,6]) * Z(3,2,[4,5,6,7,8,9]) == Q(2,2,[40,46,94,109]) - assert Z(2,3,[1,2,3,4,5,6]) * Q(3,2,[4,5,6,7,8,9]) == Q(2,2,[40,46,94,109]) - assert -Q(2,1,[2,5]) == Q(2,1,[-2,-5]) - assert +Q(1,1,[3]) == Z(1,1,[3]) - assert (Q(1,1,[1]) == 1) is False - assert (Q(1,1,[1]) != 1) is True - assert (1 == Q(1,1,[1])) is False - assert (1 != Q(1,1,[1])) is True - assert Q(1,2,[3,4]) * 2 == Q(1,2,[6,8]) - assert Q(1,2,[3,4]) * flint.fmpq(1,3) == Q(1,2,[1,flint.fmpq(4,3)]) - assert Q(1,2,[3,4]) * flint.fmpq(5,3) == Q(1,2,[5,flint.fmpq(20,3)]) - assert 2 * Q(1,2,[3,4]) == Q(1,2,[6,8]) - assert flint.fmpq(1,3) * Q(1,2,[3,4]) == Q(1,2,[1,flint.fmpq(4,3)]) - M = Q([[1,2],[3,4]]) - assert M ** -1 == Q([[-4,2],[3,-1]]) / 2 - assert M ** 0 == Q([[1,0],[0,1]]) - assert M ** 1 == M - assert M ** 2 == Q([[7,10],[15,22]]) - assert M ** 12 == Q([[138067399, 201223170],[301834755, 439902154]]) - M = Q([[1,2],[2,4]]) - assert raises(lambda: M ** -1, ZeroDivisionError) - assert Q(1,2,[3,4]) / 2 == Q(1,2,[flint.fmpq(3,2),2]) - assert Q(1,2,[3,4]) / flint.fmpq(2,3) == Q(1,2,[flint.fmpq(9,2),6]) - assert Q(3,2,range(6)).table() == Z(3,2,range(6)).table() - assert Q(3,2,range(6)).entries() == Z(3,2,range(6)).entries() - assert Q(3,2,range(6)).nrows() == 3 - assert Q(3,2,range(6)).ncols() == 2 - assert Q(2,2,[3,7,4,5]).det() == -13 - assert (Q(2,2,[3,7,4,5]) / 5).det() == flint.fmpq(-13,25) - assert raises(lambda: Q(1,2,[1,2]).det(), ValueError) - assert Q(2,2,[1,2,3,4]).inv().inv() == Q(2,2,[1,2,3,4]) - assert raises(lambda: Q(2,2,[1,1,1,1]).inv(), ZeroDivisionError) - assert raises(lambda: Q(2,1,[1,1]).inv(), ValueError) - assert raises(lambda: Q([1]), TypeError) - assert raises(lambda: Q([[1],[2,3]]), ValueError) - assert raises(lambda: Q(None), TypeError) - assert Q([[1,2,3],[4,5,6]]) == Q(2,3,[1,2,3,4,5,6]) - assert raises(lambda: Q(2,3,[1,2,3,4,5]), ValueError) - assert raises(lambda: Q([[1,2,3],[4,[],6]]), TypeError) - assert raises(lambda: Q(2,3,[1,2,3,4,[],6]), TypeError) - assert raises(lambda: Q(2,3,[1,2],[3,4]), TypeError) - assert bool(Q([[1]])) is True - assert bool(Q([[0]])) is False - assert raises(lambda: Q([[1]]) < Q([[0]]), TypeError) - M = Q([[1,2],[3,4]]) - assert M[0,1] == 2 - M[0,1] = -1 - assert M[0,1] == -1 - # XXX: Negative indices should probably be allowed - - def set_bad(i): - M[i,0] = -1 - - raises(lambda: M[-1,0], IndexError) - raises(lambda: M[0,-1], IndexError) - raises(lambda: set_bad(-1), IndexError) - raises(lambda: M[2,0], IndexError) - raises(lambda: M[0,2], IndexError) - raises(lambda: set_bad(2), IndexError) - assert Q([[1,2,3],[4,5,6]]).transpose() == Q([[1,4],[2,5],[3,6]]) - raises(lambda: M + [], TypeError) - raises(lambda: M - [], TypeError) - raises(lambda: M * [], TypeError) - raises(lambda: M / [], TypeError) - raises(lambda: [] / M, TypeError) - raises(lambda: [] + M, TypeError) - raises(lambda: [] - M, TypeError) - raises(lambda: [] * M, TypeError) - # XXX: Maybe a ShapeError? - raises(lambda: Q(1,2,[3,4]) + Q(1,3,[5,6,7]), ValueError) - raises(lambda: Q(1,2,[3,4]) - Q(1,3,[5,6,7]), ValueError) - raises(lambda: Q(1,2,[3,4]) * Q(1,3,[5,6,7]), ValueError) - raises(lambda: Q(1,2,[3,4]) * Z(1,3,[5,6,7]), ValueError) - raises(lambda: Z(1,2,[3,4]) * Q(1,3,[5,6,7]), ValueError) - A = Q([[3,4],[5,7]]) / 11 - X = Q([[1,2],[3,4]]) - B = A*X - assert A.solve(B) == X - for algorithm in None, "fflu", "dixon": - assert A.solve(B, algorithm=algorithm) == X - assert raises(lambda: A.solve(B, algorithm="invalid"), ValueError) - assert raises(lambda: A.solve(None), TypeError) - assert raises(lambda: A.solve([1,2]), TypeError) - assert raises(lambda: A.solve(Q([[1,2]])), ValueError) - assert raises(lambda: Q([[1,2],[2,4]]).solve(Q([[1],[2]])), ZeroDivisionError) - M = Q([[1,2,3],[flint.fmpq(1,2),5,6]]) - Mcopy = Q(M) - Mrref = Q([[1,0,flint.fmpq(3,4)],[0,1,flint.fmpq(9,8)]]) - assert M.rref() == (Mrref, 2) - assert M != Mrref - assert M == Mcopy - assert M.rref(inplace=True) == (Mrref, 2) - assert M == Mrref - assert M != Mcopy - assert Q.hilbert(1, 2) == Q([[1,flint.fmpq(1,2)]]) - M2 = Q([[2, 4, 6], [8, 10, 12]]) / 4 - assert M2.numer_denom() == (Q([[1,2,3],[4,5,6]]), 2) - half = flint.fmpq(1,2) - M3 = Q([[half,0,0],[0,half,1],[0,0,half]]) - assert M3.charpoly() == flint.fmpq_poly([-1,6,-12,8]) / 8 - assert M3.minpoly() == flint.fmpq_poly([1,-4,4]) / 4 - - -def test_fmpq_series(): - Qp = flint.fmpq_poly - Q = flint.fmpq_series - Zp = flint.fmpz_poly - Z = flint.fmpz_series - ctx = flint.ctx - assert ctx.cap == 10 - s1 = Q([1,2]) - s2 = Q([1,2]) - s3 = Q([1,1]) - s4 = Q([1,2],1,11) - s5 = Q([1,2],1,3) - p1 = Qp([1,2]) - sz1 = Z([1,2]) - sz2 = Z([1,1]) - sz3 = Z([1,1],11) - assert s1.prec == 10 - assert s4.prec == 11 - assert s5.prec == 3 - assert s1._equal_repr(s1) is True - assert s1._equal_repr(s2) is True - assert s1._equal_repr(s3) is False - assert s1._equal_repr(s4) is False - assert s1._equal_repr(p1) is False - assert s1._equal_repr(sz1) is False - assert s1._equal_repr(sz2) is False - assert s1._equal_repr(sz3) is False - assert Q([1])._equal_repr(flint.fmpq(1)) is False - assert Q([1])._equal_repr(1) is False - p = Q([1,2]) - assert p.prec == 10 - p4 = Q([1,2], prec=4) - assert p4.prec == 4 - p4 = Q(p, prec=4) - assert p4.prec == 4 - # XXX: this gives a core dump: - # s = Q([1,2]) - # s[10**10] = 1 - assert Q([])._equal_repr(Q([0])) - assert not Q([1])._equal_repr(Q([0])) - assert Q(Q([1]))._equal_repr(Q([1])) - assert Q(Qp([1]))._equal_repr(Q([1])) - assert Q(Zp([1]))._equal_repr(Q([1])) - assert Q(Z([1]))._equal_repr(Q([1])) - assert Q(1)._equal_repr(Q([1])) - assert Q([1],1)._equal_repr(Q([1])) - assert Q([1],2)._equal_repr(Q([flint.fmpq(1,2)])) - assert not Q([1],1,10)._equal_repr(Q([1],1,11)) - assert Q([1,2],3)._equal_repr(Q([flint.fmpq(1,3), flint.fmpq(2,3)])) - assert raises(lambda: Q([1],[]), TypeError) # type: ignore - assert raises(lambda: Q([1],0), ZeroDivisionError) - assert raises(lambda: Q([1]) < Q([1]), TypeError) # type: ignore - assert len(Q([1,2])) == 2 - assert Q([1,2]).length() == 2 - s5 = Q([1,2]) - assert s5[1] == 2 - assert s5[2] == 0 - assert s5[-1] == 0 - # XXX: This goes beyond cap. Should it give an error? - assert s5[100] == 0 - s5[2] = -1 - assert s5[2] == -1 - assert s5._equal_repr(Q([1,2,-1])) - - def set_bad(): - s5[-1] = 3 - - assert raises(set_bad, ValueError) - assert Q([1,2,1]).coeffs() == list(Q([1,2,1])) == [1,2,1] - assert Q([1,2,1],2).coeffs() == [flint.fmpq(1,2),1,flint.fmpq(1,2)] - assert Q([1,2,0,4]).str() == "1 + 2*x + 4*x^3 + O(x^10)" - assert Q([1,2,0,4]).repr() == "fmpq_series([1, 2, 0, 4], 1, prec=10)" - assert Q([],1,0).str() == "O(x^0)" - assert Q([],1,-1).str() == "(invalid power series)" - assert (+Q([1,2]))._equal_repr(Q([1,2])) - assert (-Q([1,2]))._equal_repr(Q([-1,-2])) - assert (Q([1,2]) + Q([3,4,5]))._equal_repr(Q([4,6,5])) - assert (Q([1,2]) + 1)._equal_repr(Q([2,2])) - assert (Q([1,2]) + Qp([3,4,5]))._equal_repr(Q([4,6,5])) - assert (1 + Q([1,2]))._equal_repr(Q([2,2])) - assert (Qp([1,2]) + Q([3,4,5]))._equal_repr(Q([4,6,5])) - assert raises(lambda: Q([1,2]) + [], TypeError) # type: ignore - assert raises(lambda: [] + Q([1,2]), TypeError) # type: ignore - assert (Q([1,2]) - Q([3,5]))._equal_repr(Q([-2,-3])) - assert (Q([1,2]) - 1)._equal_repr(Q([0,2])) - assert (1 - Q([1,2]))._equal_repr(Q([0,-2])) - assert raises(lambda: [] - Q([1,2]), TypeError) # type: ignore - assert raises(lambda: Q([1,2]) - [], TypeError) # type: ignore - assert (Q([1,2]) * Q([1,2]))._equal_repr(Q([1,4,4])) - assert (2 * Q([1,2]))._equal_repr(Q([2,4])) - assert (Q([1,2]) * 2)._equal_repr(Q([2,4])) - assert raises(lambda: [] * Q([1,2]), TypeError) # type: ignore - assert raises(lambda: Q([1,2]) * [], TypeError) # type: ignore - assert Q([1,2]).valuation() == 0 - assert Q([0,2]).valuation() == 1 - assert Q([0,0]).valuation() == -1 - assert (Q([1,1]) / Q([1,-1]))._equal_repr(Q([1,2,2,2,2,2,2,2,2,2])) - assert raises(lambda: Q([1,1]) / Q([]), ZeroDivisionError) - assert (Q([],1) / Q([1,-1]))._equal_repr(Q([],1)) - # quotient would not be a power series - assert raises(lambda: Q([1,1]) / Q([0,1]), ValueError) - assert (Q([1,1]) / Q([2,1]))._equal_repr(Q([512, 256, -128, 64, -32, 16, -8, 4, -2, 1], 1024)) - assert (Q([0,1,1]) / Q([0,1,-1]))._equal_repr(Q([1,2,2,2,2,2,2,2,2],1,9)) - assert (Q([2,4]) / 2)._equal_repr(Q([1,2])) - assert (Q([1,4]) / 2)._equal_repr(Q([1,4],2)) - assert (Q([1,1]) / -1)._equal_repr(Q([-1,-1])) - assert raises(lambda: Q([1,1]) / [], TypeError) # type: ignore - assert raises(lambda: [] / Q([1,1]), TypeError) # type: ignore - q = Q([1,2],3) - assert (q ** 0)._equal_repr(Q([1])) - assert (q ** 1)._equal_repr(q) - assert (q ** 2)._equal_repr(Q([1,4,4],9)) - assert (q ** 3)._equal_repr(Q([1,6,12,8],27)) - assert (q ** 4)._equal_repr(Q([1, 8, 24, 32, 16], 81)) - assert (Q([1,2]) ** 2)._equal_repr(Q([1,4,4])) - assert (Q([1,2]) ** 2)._equal_repr(Q([1,4,4])) - assert raises(lambda: pow(Q([1,2]), 3, 5), NotImplementedError) # type: ignore - assert (Q([1,2])(Q([0,1,2])))._equal_repr(Q([1,2,4])) - assert raises(lambda: Q([1,2])(Q([1,2])), ValueError) - assert raises(lambda: Q([1,2])([]), TypeError) # type: ignore - coeffs = [0, 1, -2, 8, -40, 224, -1344, 8448, -54912, 366080] - assert Q([0,1,2]).reversion()._equal_repr(Q(coeffs)) - # power series reversion must have valuation 1 - assert raises(lambda: Q([1,1]).reversion(), ValueError) - assert Q([0,2,1]).reversion()._equal_repr( - Q([0,32768,-8192,4096,-2560,1792,-1344,1056,-858,715],65536,10)) - x = Q([0,1]) - expx = x.exp() - assert (expx)._equal_repr(Q([362880,362880,181440,60480,15120,3024,504,72,9,1],362880)) - assert (expx.inv())._equal_repr(Q([362880,-362880,181440,-60480,15120,-3024,504,-72,9,-1], 362880)) - assert (expx.derivative())._equal_repr(Q([40320,40320,20160,6720,1680,336,56,8,1],40320,prec=9)) - assert (Q([1,1]).integral())._equal_repr(Q([0,2,1],2)) - assert (expx.sqrt())._equal_repr( - Q([185794560,92897280,23224320,3870720,483840,48384,4032,288,18,1],185794560)) - assert (expx.rsqrt())._equal_repr( - Q([185794560,-92897280,23224320,-3870720,483840,-48384,4032,-288,18,-1],185794560)) - assert (expx.log())._equal_repr(x) - zero = Q() - one = Q([1]) - assert (zero.exp())._equal_repr(one) - assert (one.log())._equal_repr(zero) - assert (x.atan())._equal_repr(Q([0,315,0,-105,0,63,0,-45,0,35],315)) - assert (x.atanh())._equal_repr(Q([0,315,0,105,0,63,0,45,0,35],315)) - assert (x.asin())._equal_repr(Q([0,40320,0,6720,0,3024,0,1800,0,1225],40320)) - assert (x.asinh())._equal_repr(Q([0,40320,0,-6720,0,3024,0,-1800,0,1225],40320)) - assert (x.sin())._equal_repr(Q([0,362880,0,-60480,0,3024,0,-72,0,1],362880)) - assert (x.cos())._equal_repr(Q([40320,0,-20160,0,1680,0,-56,0,1],40320)) - assert (x.tan())._equal_repr(Q([0,2835,0,945,0,378,0,153,0,62],2835)) - assert (x.sinh())._equal_repr(Q([0,362880,0,60480,0,3024,0,72,0,1],362880)) - assert (x.cosh())._equal_repr(Q([40320,0,20160,0,1680,0,56,0,1],40320)) - assert (x.tanh())._equal_repr(Q([0,2835,0,-945,0,378,0,-153,0,62],2835)) - # Constant term must be nonzero - assert raises(lambda: Q([0,1]).inv(), ValueError) - # Constant term must be 1 - assert raises(lambda: Q([2,1]).sqrt(), ValueError) - assert raises(lambda: Q([2,1]).rsqrt(), ValueError) - assert raises(lambda: Q([2,1]).log(), ValueError) - assert raises(lambda: Q([]).sqrt(), ValueError) - assert raises(lambda: Q([]).rsqrt(), ValueError) - assert raises(lambda: Q([]).log(), ValueError) - # Constant term must be 0 - assert raises(lambda: Q([1,1]).exp(), ValueError) - assert raises(lambda: Q([1,1]).atan(), ValueError) - assert raises(lambda: Q([1,1]).atanh(), ValueError) - assert raises(lambda: Q([1,1]).asin(), ValueError) - assert raises(lambda: Q([1,1]).asinh(), ValueError) - assert raises(lambda: Q([1,1]).sin(), ValueError) - assert raises(lambda: Q([1,1]).cos(), ValueError) - assert raises(lambda: Q([1,1]).tan(), ValueError) - assert raises(lambda: Q([1,1]).sinh(), ValueError) - assert raises(lambda: Q([1,1]).cosh(), ValueError) - assert raises(lambda: Q([1,1]).tanh(), ValueError) - -def test_nmod(): - G = flint.nmod - assert G(0,2) == G(2,2) == G(-2,2) - assert G(1,2) != G(0,2) - assert G(0,2) != G(0,3) - assert G(3,5) == G(8,5) - assert G(1,2) != (1,2) - assert isinstance(hash(G(3, 5)), int) - assert raises(lambda: G([], 3), TypeError) # type: ignore - #assert G(3,5) == 8 # do we want this? - #assert 8 == G(3,5) - assert G(3,5) != 7 - assert 7 != G(3,5) - assert raises(lambda: G(3,5) < G(2,5), TypeError) # type: ignore - assert bool(G(0,5)) is False - assert bool(G(2,5)) is True - assert G(-3,5) == -G(3,5) == G(2,5) == +G(2,5) - assert G(2,5) + G(1,5) == G(3,5) - assert G(2,5) + 1 == G(3,5) - assert 1 + G(2,5) == G(3,5) - assert G(2,5) - G(3,5) == G(4,5) - assert G(2,5) - 3 == G(4,5) - assert 3 - G(2,5) == G(1,5) - assert G(2,5) * G(3,5) == G(1,5) - assert G(2,5) * 3 == G(1,5) - assert 3 * G(2,5) == G(1,5) - assert G(3,17) / G(2,17) == G(10,17) - assert G(3,17) / 2 == G(10,17) - assert 3 / G(2,17) == G(10,17) - assert G(0,3) / G(1,3) == G(0,3) - assert G(3,17) * flint.fmpq(11,5) == G(10,17) - assert G(3,17) / flint.fmpq(11,5) == G(6,17) - assert raises(lambda: G(flint.fmpq(2, 3), 3), ZeroDivisionError) - assert raises(lambda: G(2,5) / G(0,5), ZeroDivisionError) - assert raises(lambda: G(2,5) / 0, ZeroDivisionError) - assert G(1,6) / G(5,6) == G(5,6) - assert raises(lambda: G(1,6) / G(3,6), ZeroDivisionError) - assert G(1,3) ** 2 == G(1,3) - assert G(2,3) ** flint.fmpz(2) == G(1,3) - assert ~G(2,7) == G(2,7) ** -1 == G(4,7) - assert raises(lambda: G(3,6) ** -1, ZeroDivisionError) - assert raises(lambda: ~G(3,6), ZeroDivisionError) - assert raises(lambda: pow(G(1,3), 2, 7), TypeError) # type: ignore - assert G(flint.fmpq(2, 3), 5) == G(4,5) - assert raises(lambda: G(2,5) ** G(2,5), TypeError) # type: ignore - assert raises(lambda: flint.fmpz(2) ** G(2,5), TypeError) # type: ignore - assert raises(lambda: G(2,5) + G(2,7), ValueError) - assert raises(lambda: G(2,5) - G(2,7), ValueError) - assert raises(lambda: G(2,5) * G(2,7), ValueError) - assert raises(lambda: G(2,5) / G(2,7), ValueError) - assert raises(lambda: G(2,5) + [], TypeError) # type: ignore - assert raises(lambda: G(2,5) - [], TypeError) # type: ignore - assert raises(lambda: G(2,5) * [], TypeError) # type: ignore - assert raises(lambda: G(2,5) / [], TypeError) # type: ignore - assert raises(lambda: G(2,5) ** [], TypeError) # type: ignore - assert raises(lambda: [] + G(2,5), TypeError) # type: ignore - assert raises(lambda: [] - G(2,5), TypeError) # type: ignore - assert raises(lambda: [] * G(2,5), TypeError) # type: ignore - assert raises(lambda: [] / G(2,5), TypeError) # type: ignore - assert raises(lambda: [] ** G(2,5), TypeError) # type: ignore - assert G(3,17).modulus() == 17 - assert str(G(3,5)) == "3" - assert G(3,5).repr() == "nmod(3, 5)" - -def test_nmod_poly(): - N = flint.nmod - P = flint.nmod_poly - Z = flint.fmpz_poly - assert P([],17) == P([0],17) - assert P([1,2,3],17) == P([1,2,3],17) - assert P([1,2,3],17) != P([1,2,3],15) - assert P([1,2,3],17) != P([1,2,4],15) - assert P([1,2,3],17) != 1 - assert P([1,2,3],17) != Z([1,2,3]) - assert raises(lambda: P([1,2],3) < P([1,2],3), TypeError) # type: ignore - assert P(Z([1,2,3]),17) == P([1,2,3],17) - assert P([1,2,N(3,17)],17) == P([1,2,3],17) - assert P(P([1,2],17),17) == P([1,2],17) - assert raises(lambda: P(P([1,2],17),13), ValueError) - assert raises(lambda: P([1,2,[]],17), TypeError) # type: ignore - assert raises(lambda: P([1,2,flint.nmod(3,15)],17), ValueError) - assert raises(lambda: P([1,2],0), ValueError) - assert raises(lambda: P({},3), TypeError) # type: ignore - assert P([1,2,3],17).degree() == 2 - assert P([1,2,3],17).length() == 3 - assert len(P([1,2,3],17)) == 3 - assert P([1,2,3],5).coeffs() == [N(1,5),N(2,5),N(3,5)] - assert P([1,2,3],17) + 2 == P([3,2,3],17) - assert 2 + P([1,2,3],17) == P([3,2,3],17) - assert P([1,2,3],17) + P([3,4,5],17) == P([4,6,8],17) - assert P([1,2,3],17) + P([3,4,5],17) == P([4,6,8],17) - assert P([1,2,3],17) - 2 == P([16,2,3],17) - assert 2 - P([1,2,3],17) == -P([16,2,3],17) - assert +P([1,2,3],17) == P([1,2,3],17) - assert P([1,2,3],17) - P([3,4,6],17) == P([15,15,14],17) - assert P([1,2,3],17) * 2 == P([2,4,6],17) - assert 2 * P([1,2,3],17) == P([2,4,6],17) - assert P([1,2,3],17) * P([1,2,3],17) == P([1,4,10,12,9], 17) - assert P([1,2,3],17) * Z([1,2,3]) == P([1,4,10,12,9], 17) - assert Z([1,2,3]) * P([1,2,3],17) == P([1,4,10,12,9], 17) - assert P([1,2,3,4,5],17) % P([2,3,4],17) == P([12,12],17) - assert P([1,2,3,4,5],17) // P([2,3,4],17) == P([3,16,14],17) - assert raises(lambda: P([1,2],5) // P([],5), ZeroDivisionError) - assert raises(lambda: P([1,2],5) % P([],5), ZeroDivisionError) - assert raises(lambda: divmod(P([1,2],5), P([],5)), ZeroDivisionError) - assert P([1,2,3,4,5],17) ** 2 == P([1,2,3,4,5],17) * P([1,2,3,4,5],17) - assert P([1,2,3],17) * N(3,17) == P([3,6,9],17) - s = P([1,2,3],17) - s2 = P([1,2,3],5) - assert raises(lambda: s + s2, ValueError) - assert raises(lambda: s - s2, ValueError) - assert raises(lambda: s * s2, ValueError) - assert raises(lambda: s // s2, ValueError) - assert raises(lambda: s % s2, ValueError) - assert raises(lambda: s2 + s, ValueError) - assert raises(lambda: s2 - s, ValueError) - assert raises(lambda: s2 * s, ValueError) - assert raises(lambda: s2 // s, ValueError) - assert raises(lambda: s2 % s, ValueError) - assert raises(lambda: s + [], TypeError) # type: ignore - assert raises(lambda: s - [], TypeError) # type: ignore - assert raises(lambda: s * [], TypeError) # type: ignore - assert raises(lambda: s // [], TypeError) # type: ignore - assert raises(lambda: s % [], TypeError) # type: ignore - assert raises(lambda: [] + s, TypeError) # type: ignore - assert raises(lambda: [] - s, TypeError) # type: ignore - assert raises(lambda: [] * s, TypeError) # type: ignore - assert raises(lambda: [] // s, TypeError) # type: ignore - assert raises(lambda: [] % s, TypeError) # type: ignore - assert raises(lambda: [] % s, TypeError) # type: ignore - assert raises(lambda: s.reverse(-1), ValueError) - assert raises(lambda: s.compose("A"), TypeError) # type: ignore - assert raises(lambda: s.compose_mod(s, "A"), TypeError) # type: ignore - assert raises(lambda: s.compose_mod("A", P([3,6,9],17)), TypeError) # type: ignore - assert raises(lambda: s.compose_mod(s, P([0], 17)), ZeroDivisionError) - assert raises(lambda: pow(s, -1, P([3,6,9],17)), ValueError) - assert raises(lambda: pow(s, 1, "A"), TypeError) # type: ignore - assert raises(lambda: pow(s, "A", P([3,6,9],17)), TypeError) # type: ignore - assert str(P([1,2,3],17)) == "3*x^2 + 2*x + 1" - assert P([1,2,3],17).repr() == "nmod_poly([1, 2, 3], 17)" - p = P([3,4,5],17) - assert p(14) == N(2,17) - assert p(P([1,2,3],17)) == P([12,11,11,9,11],17) - assert raises(lambda: p({}), TypeError) # type: ignore - p2 = P([3,4,5],17) - assert p2[1] == N(4,17) - assert p2[-1] == N(0,17) - p2[1] = N(2,17) - assert p2 == P([3,2,5],17) - p2[1] = 6 - assert p2 == P([3,6,5],17) - - def set_bad1(): - p2[-1] = 3 - - def set_bad2(): - p2[2] = [] # type: ignore - - assert raises(set_bad1, ValueError) - assert raises(set_bad2, TypeError) - assert bool(P([], 5)) is False - assert bool(P([1], 5)) is True - assert P([1,2,1],3).gcd(P([1,1],3)) == P([1,1],3) - raises(lambda: P([1,2],3).gcd([]), TypeError) # type: ignore - raises(lambda: P([1,2],3).gcd(P([1,2],5)), ValueError) - p3 = P([1,2,3,4,5,6],7) - f3 = (N(6,7), [(P([6, 1],7), 5)]) - assert p3.factor() == f3 - # XXX: factor ignores an invalid algorithm string - for alg in [None, 'berlekamp', 'cantor-zassenhaus']: - assert p3.factor(alg) == f3 - assert p3.factor(algorithm=alg) == f3 - assert P([1], 11).roots() == [] - assert P([1, 2, 3], 11).roots() == [(8, 1), (6, 1)] - assert P([1, 6, 1, 8], 11).roots() == [(5, 3)] - assert raises(lambda: P([1, 2, 3], 11).real_roots(), DomainError) - assert raises(lambda: P([1, 2, 3], 11).complex_roots(), DomainError) - - -def test_nmod_mat(): - M = flint.nmod_mat - G = flint.nmod - Z = flint.fmpz_mat - a = M(2,3,[1,2,3,4,5,6],17) - b = M(2,3,[4,5,6,7,8,9],17) - assert a == a - assert a == M(a) - assert a != b - assert a.nrows() == 2 - assert a.ncols() == 3 - assert a.entries() == [G(x,17) for x in [1,2,3,4,5,6]] - assert a.table() == [[G(x,17) for x in [1,2,3]], [G(x,17) for x in [4,5,6]]] - assert (a + b).entries() == [G(x,17) for x in [5,7,9,11,13,15]] - assert raises(a.det, ValueError) - assert +a == a - assert -a == M(2,3,[-1,-2,-3,-4,-5,-6],17) - c = M(2,2,[1,2,3,4],17) - assert c.det() == G(-2,17) - assert raises(lambda: a + c, ValueError) - assert (a * 3).entries() == [G(x,17) for x in [3,6,9,12,15,18]] - assert (3 * a).entries() == [G(x,17) for x in [3,6,9,12,15,18]] - assert (a * flint.fmpz(3)).entries() == [G(x,17) for x in [3,6,9,12,15,18]] - assert (flint.fmpz(3) * a).entries() == [G(x,17) for x in [3,6,9,12,15,18]] - assert M(2,2,[1,1,2,2],17).rank() == 1 - assert M(Z(2,2,[1,2,3,4]),17) == M(2,2,[1,2,3,4],17) - A = M(5,3,Z.randbits(5,3,5).entries(),17) - B = M(3,7,Z.randtest(3,7,5).entries(),17) - C = M(7,2,Z.randtest(7,2,5).entries(),17) - assert A*(B*C) == (A*B)*C - assert bool(M(2,2,[0,0,0,0],17)) is False - assert bool(M(2,2,[0,0,0,1],17)) is True - pretty = ctx.pretty - try: - ctx.pretty = False - assert repr(M(2,2,[1,2,3,4],17)) == 'nmod_mat(2, 2, [1, 2, 3, 4], 17)' - finally: - ctx.pretty = pretty - assert str(M(2,2,[1,2,3,4],17)) == '[1, 2]\n[3, 4]' - assert repr(M(2,2,[1,2,3,4],17)) == '[1, 2]\n[3, 4]' - assert M(1,2,[3,4],17) / 3 == M(1,2,[3,4],17) * (~G(3,17)) - assert M(2,2,[1,2,3,4], 17).inv().det() == ~(M(2,2,[1,2,3,4], 17).det()) - assert M(2,2,[1,2,3,4], 17).inv().inv() == M(2,2,[1,2,3,4], 17) - assert M(2,2,[0,1,2,3],17) * M(2, 2, [2,3,4,5], 17) == M(2,2,[4,5,16,4],17) - assert raises(lambda: M([1], 5), TypeError) - assert raises(lambda: M([[1],[2,3]], 5), ValueError) - assert raises(lambda: M([[1],[2]], 0), ValueError) - assert raises(lambda: M(None), TypeError) - assert raises(lambda: M(None,17), TypeError) - assert M(2,3,17) == M(2,3,[0,0,0,0,0,0],17) - assert raises(lambda: M(2,3,[0,0,0,0,0],17), ValueError) - assert raises(lambda: M(2,3,[0,1],[1,2],17), TypeError) - assert M([[1,2,3],[4,5,6]], 5) == M(2,3,[1,2,3,4,5,6], 5) - assert raises(lambda: M([[0]],13) < M([[1]],13), TypeError) - assert (M([[1]],17) == M([[1]],13)) is False - assert (M([[1]],17) != M([[1]],13)) is True - assert (M([[1]],17) == None) is False - assert (M([[1]],17) != None) is True - M2 = M.randtest(3,4,5) - assert all(0 <= int(x) < 5 for x in M2.entries()) - assert (M2.nrows(), M2.ncols()) == (3, 4) - M3 = M(2,2,[1,2,3,4],17) - assert M3[0,1] == G(2,17) - M3_copy = M(M3) - M3[0,1] = -1 - assert M3[0,1] == G(-1,17) - assert M3_copy[0,1] == G(2,17) - - def set_bad(i,j): - M3[i,j] = 2 - - # XXX: negative indices should be allowed - assert raises(lambda: M3[-1,0], IndexError) - assert raises(lambda: M3[0,-1], IndexError) - assert raises(lambda: set_bad(-1,0), IndexError) - assert raises(lambda: set_bad(0,-1), IndexError) - assert raises(lambda: M3[2,0], IndexError) - assert raises(lambda: M3[0,2], IndexError) - assert raises(lambda: set_bad(2,0), IndexError) - assert raises(lambda: set_bad(0,2), IndexError) - - def set_bad2(): - M3[0,0] = 1.5 - - assert raises(set_bad2, TypeError) - assert raises(lambda: M3 + [], TypeError) - assert raises(lambda: M3 - [], TypeError) - assert raises(lambda: M3 * [], TypeError) - assert raises(lambda: M3 / [], TypeError) - assert raises(lambda: [] + M3, TypeError) - assert raises(lambda: [] - M3, TypeError) - assert raises(lambda: [] * M3, TypeError) - assert raises(lambda: [] / M3, TypeError) - assert raises(lambda: M([[1]],3) + M([[1]],5), ValueError) - assert raises(lambda: M([[1]],3) - M([[1]],5), ValueError) - assert raises(lambda: M([[1]],3) * M([[1]],5), ValueError) - assert Z([[1]]) + M([[1]],3) == M([[2]],3) - assert M([[1]],3) + Z([[1]]) == M([[2]],3) - assert Z([[1]]) - M([[1]],3) == M([[0]],3) - assert M([[1]],3) - Z([[1]]) == M([[0]],3) - assert Z([[1]]) * M([[1]],3) == M([[1]],3) - assert M([[1]],3) * Z([[1]]) == M([[1]],3) - assert raises(lambda: M([[1]],3) - M([[1,2]],3), ValueError) - assert raises(lambda: M([[1,2]],3) * M([[1,2]],3), ValueError) - M4 = M([[1,2],[3,4]],17) - assert M4.inv() == M([[15,1],[10,8]],17) - assert raises(lambda: M([[1,2]],17).inv(), ValueError) - assert raises(lambda: M([[1,2],[2,4]],17).inv(), ZeroDivisionError) - assert M([[1,2,3],[4,5,6]],17).transpose() == M([[1,4],[2,5],[3,6]],17) - M5 = M([[1,2],[3,4]],17) - X = M([[1],[2]],17) - b = M5*X - assert M5.solve(b) == X - assert raises(lambda: M5.solve([]), TypeError) - assert raises(lambda: b.solve(M5), ValueError) - assert raises(lambda: M([[1,2],[2,4]],17).solve(b), ZeroDivisionError) - M6 = M([[1,2,3],[4,5,6]],17) - M6_rref = M([[1,0,16],[0,1,2]],17) - M6_copy = M(M6) - assert M6.rref() == (M6_rref, 2) - assert M6 == M6_copy - assert M6.rref(inplace=True) == (M6_rref, 2) - assert M6 == M6_rref - M6 = M6_copy - assert M6.nullspace() == (M([[1,15,1],[0,0,0],[0,0,0]],17).transpose(), 1) - - -def test_nmod_series(): - # XXX: currently no code in nmod_series.pyx - pass - - -def test_arb(): - arb = flint.arb - assert arb(3) > arb(2.5) - assert arb(3) >= arb("2.5") - assert arb(3) < arb((3,1)) - assert arb(3) <= arb("inf") - assert arb(3) == arb(3) - assert arb(3) != arb(2) - assert -arb(3) == arb(-3) - assert arb(3).neg() == arb(-3) - assert not (arb("1.1") == arb("1.1")) - - assert arb(3).repr() == 'arb((0x3, 0x0))' - assert arb("nan").repr() == "arb('nan')" - assert arb(0, "inf").repr() == "arb(0.0, '+inf')" - assert arb((1,2), (3,4)).repr() == "arb((0x1, 0x2), (0x3, 0x4))" - assert arb(1, arb("inf")).repr() == "arb((0x1, 0x0), '+inf')" - assert arb(1, "inf").repr() == "arb((0x1, 0x0), '+inf')" - assert arb(1, "nan").repr() == "arb((0x1, 0x0), '+inf')" - assert arb("nan", 1).repr() == "arb('nan')" - assert arb("nan", "nan").repr() == "arb('nan')" - - for a in [arb(2), arb((1,2), (3,4)), arb("nan"), arb(0, "inf")]: - assert eval(a.repr()).repr() == a.repr() - - -def test_acb(): - acb = flint.acb - assert acb(1, 2).repr() == "acb(arb((0x1, 0x0)), arb((0x1, 0x1)))" - - -def test_pickling(): - objects = [ - flint.fmpz(1), - flint.fmpq(1,2), - # XXX: Add pickling for everything else - ] - for obj in objects: - s = pickle.dumps(obj) - obj2 = pickle.loads(s) - assert obj == obj2 - - -def test_fmpz_mod(): - from flint import fmpz_mod_ctx, fmpz, fmpz_mod - - p_sml = 163 - p_med = 2**127 - 1 - p_big = 2**255 - 19 - - F_cmp = fmpz_mod_ctx(10) - F_sml = fmpz_mod_ctx(p_sml) - F_med = fmpz_mod_ctx(p_med) - F_big = fmpz_mod_ctx(p_big) - - assert F_sml.is_prime() is True - assert F_med.is_prime() is True - assert F_big.is_prime() is True - assert F_cmp.is_prime() is False - - # Context tests - assert raises(lambda: fmpz_mod_ctx("AAA"), TypeError) # type: ignore - assert raises(lambda: fmpz_mod_ctx(-1), ValueError) - assert F_sml.modulus() == p_sml - assert F_med.modulus() == p_med - assert F_big.modulus() == p_big - - F_big_copy = fmpz_mod_ctx(p_big) - assert F_big_copy == F_big - assert F_big != F_sml - assert hash(F_big_copy) == hash(F_big) - assert hash(F_big) != hash(F_sml) - assert F_big_copy != F_sml - assert F_big_copy != "A" - - assert repr(F_sml) == "fmpz_mod_ctx(163)" - assert str(F_sml) == "Context for fmpz_mod with modulus: 163" - - # Type tests - assert raises(lambda: fmpz_mod(1, "AAA"), TypeError) # type: ignore - - # Test for small, medium and large char. - for F_test in [F_sml, F_med, F_big]: - test_mod = int(F_test.modulus()) - test_x = (-123) % test_mod # canonical value - test_y = ((-456) % test_mod)**2 # non-canoncial value - - test_z = F_test.random_element() - assert int(test_z) < F_test.modulus() - assert int(test_z) >= 0 - - assert raises(lambda: F_test(F_cmp(1)), ValueError) - assert raises(lambda: F_test("abc"), NotImplementedError) # type: ignore - - F_test_copy = fmpz_mod_ctx(test_mod) - F_other = fmpz_mod_ctx(11) - - assert raises(lambda: F_test(test_x) > 0, TypeError) # type: ignore - assert raises(lambda: F_test(test_x) >= 0, TypeError) # type: ignore - assert raises(lambda: F_test(test_x) < 0, TypeError) # type: ignore - assert raises(lambda: F_test(test_x) <= 0, TypeError) # type: ignore - - assert (test_x == F_test(test_x)) is True, f"{test_x}, {F_test(test_x)}" - assert (124 != F_test(test_x)) is True - assert (F_test(test_x) == test_x) is True - assert (F_test(test_x) == test_x + test_mod) is True - assert (F_test(test_x) == 1) is False - assert (F_test(test_x) != 1) is True - assert (F_test(test_x) == F_test(test_x)) is True - assert (F_test(test_x) == F_test(test_x + test_mod)) is True - assert (F_test(test_x) == F_test(1)) is False - assert (F_test(test_x) != F_test(1)) is True - assert (F_test(test_x) != "abc") is True - - assert (hash(F_test(test_x)) == hash(test_x)) is True - assert (hash(F_test(F_test(test_x))) == hash(test_x)) is True - assert (hash(F_test(test_x)) == hash(1)) is False - assert (hash(F_test(test_x)) != hash(1)) is True - assert (hash(F_test(test_x)) == hash(F_test(test_x))) is True - assert (hash(F_test(test_x)) == hash(F_test(test_x + test_mod))) is True - assert (hash(F_test(test_x)) == hash(F_test(1))) is False - assert (hash(F_test(test_x)) != hash(F_test(1))) is True - - # Is one, zero - assert (F_test(0) == 0) is True - assert F_test(0).is_zero() is True - assert not F_test(0) - assert not F_test(test_mod) - assert F_test(1).is_one() is True - assert F_test(test_mod + 1).is_one() is True - assert F_test(1).is_one() is True - assert F_test(2).is_one() is False - - # int, str, repr - assert str(F_test(11)) == "11" - assert str(F_test(-1)) == str(test_mod - 1) - assert repr(F_test(11)) == f"fmpz_mod(11, {test_mod})" - assert repr(F_test(-1)) == f"fmpz_mod({test_mod - 1}, {test_mod})" - - assert +F_test(5) == F_test(5) - - # Arithmetic tests - - # Negation - assert -F_test(test_x) == F_test(-test_x) == (-test_x % test_mod) - assert -F_test(1) == F_test(-1) == F_test(test_mod - 1) - - # Addition - assert F_test(test_x) + F_test(test_y) == F_test(test_x + test_y) - assert F_test(test_x) + F_test_copy(test_y) == F_test(test_x + test_y) - assert F_test(test_x) + F_test(test_y) == F_test_copy(test_x + test_y) - assert raises(lambda: F_test(test_x) + "AAA", TypeError) # type: ignore - - assert F_test(test_x) + F_test(test_y) == F_test(test_y) + F_test(test_x) - assert F_test(test_x) + test_y == F_test(test_x + test_y) - assert test_y + F_test(test_x) == F_test(test_x + test_y) - assert F_test(test_x) + fmpz(test_y) == F_test(test_y) + F_test(test_x) - assert raises(lambda: F_test(test_x) + F_other(test_y), ValueError) - - # Subtraction - - assert F_test(test_x) - F_test(test_y) == F_test(test_x - test_y) - assert F_test(test_x) - test_y == F_test(test_x - test_y) - assert F_test(test_x) - test_y == F_test(test_x) - F_test(test_y) - assert F_test(test_y) - test_x == F_test(test_y) - F_test(test_x) - assert test_x - F_test(test_y) == F_test(test_x) - F_test(test_y) - assert test_y - F_test(test_x) == F_test(test_y) - F_test(test_x) - assert F_test(test_x) - fmpz(test_y) == F_test(test_x) - F_test(test_y) - assert raises(lambda: F_test(test_x) - F_other(test_y), ValueError) - assert raises(lambda: F_test(test_x) - "AAA", TypeError) # type: ignore - assert raises(lambda: "AAA" - F_test(test_x), TypeError) # type: ignore - - # Multiplication - - assert F_test(test_x) * F_test(test_y) == (test_x * test_y) % test_mod - assert F_test(test_x) * test_y == (test_x * test_y) % test_mod - assert test_y * F_test(test_x) == (test_x * test_y) % test_mod - - assert F_test(1) * F_test(test_x) == F_test(1 * test_x) - assert F_test(2) * F_test(test_x) == F_test(2 * test_x) - assert F_test(3) * F_test(test_x) == F_test(3 * test_x) - assert 1 * F_test(test_x) == F_test(1 * test_x) - assert 2 * F_test(test_x) == F_test(2 * test_x) - assert 3 * F_test(test_x) == F_test(3 * test_x) - assert F_test(test_x) * 1 == F_test(1 * test_x) - assert F_test(test_x) * 2 == F_test(2 * test_x) - assert F_test(test_x) * 3 == F_test(3 * test_x) - assert fmpz(1) * F_test(test_x) == F_test(1 * test_x) - assert fmpz(2) * F_test(test_x) == F_test(2 * test_x) - assert fmpz(3) * F_test(test_x) == F_test(3 * test_x) - assert raises(lambda: F_test(test_x) * "AAA", TypeError) # type: ignore - assert raises(lambda: F_test(test_x) * F_other(test_x), ValueError) - - # Exponentiation - - assert F_test(0)**0 == pow(0, 0, test_mod) - assert F_test(0)**1 == pow(0, 1, test_mod) - assert F_test(0)**2 == pow(0, 2, test_mod) - assert raises(lambda: F_test(0)**(-1), ZeroDivisionError) - assert raises(lambda: F_test(0)**("AA"), TypeError) # type: ignore - - assert F_test(test_x)**fmpz(0) == pow(test_x, 0, test_mod) - assert F_test(test_x)**fmpz(1) == pow(test_x, 1, test_mod) - assert F_test(test_x)**fmpz(2) == pow(test_x, 2, test_mod) - assert F_test(test_x)**fmpz(3) == pow(test_x, 3, test_mod) - - assert F_test(test_x)**0 == pow(test_x, 0, test_mod) - assert F_test(test_x)**1 == pow(test_x, 1, test_mod) - assert F_test(test_x)**2 == pow(test_x, 2, test_mod) - assert F_test(test_x)**3 == pow(test_x, 3, test_mod) - assert F_test(test_x)**100 == pow(test_x, 100, test_mod) - - assert F_test(test_x)**(-1) == pow(test_x, -1, test_mod) - assert F_test(test_x)**(-2) == pow(test_x, -2, test_mod) - assert F_test(test_x)**(-3) == pow(test_x, -3, test_mod) - assert F_test(test_x)**(-4) == pow(test_x, -4, test_mod) - - # Inversion - - assert raises(lambda: ~F_test(0), ZeroDivisionError) - assert ~F_test(test_x) == pow(test_x, -1, test_mod) - assert ~F_test(1) == pow(1, -1, test_mod) - assert ~F_test(2) == pow(2, -1, test_mod), f"Broken!! {~F_test(2)}, {pow(2, -1, test_mod)}" - - assert F_test(1).inverse(check=False) == pow(1, -1, test_mod) - assert F_test(2).inverse(check=False) == pow(2, -1, test_mod) - assert F_test(test_x).inverse(check=False) == pow(test_x, -1, test_mod) - - # Division - assert raises(lambda: F_test(1) / F_test(0), ZeroDivisionError) - assert F_test(test_x) / F_test(test_y) == (test_x * pow(test_y, -1, test_mod)) % test_mod - assert F_test(test_x) / fmpz(test_y) == (test_x * pow(test_y, -1, test_mod)) % test_mod - assert F_test(test_x) / test_y == (test_x * pow(test_y, -1, test_mod)) % test_mod - assert raises(lambda: F_test(test_x) / "AAA", TypeError) # type: ignore - assert raises(lambda: "AAA" / F_test(test_x), TypeError) # type: ignore - assert raises(lambda: F_other(test_x) / F_test(test_x), ValueError) - assert raises(lambda: F_test(test_x) // F_test(test_x), TypeError) # type: ignore - assert 1 / F_test(2) == pow(2, -1, test_mod) - assert 1 / F_test(test_x) == pow(test_x, -1, test_mod) - assert 1 / F_test(test_y) == pow(test_y, -1, test_mod) - - assert fmpz(test_y) / F_test(test_x) == (test_y * pow(test_x, -1, test_mod)) % test_mod - assert test_y / F_test(test_x) == (test_y * pow(test_x, -1, test_mod)) % test_mod - - -def test_fmpz_mod_dlog(): - from flint import fmpz, fmpz_mod_ctx - - # Input modulus must be prime - F = fmpz_mod_ctx(4) - g, a = F(1), F(2) - assert raises(lambda: g.discrete_log(a), NotImplementedError) - - # Moduli must match - F1, F2 = fmpz_mod_ctx(2), fmpz_mod_ctx(3) - g = F1(2) - a = F2(4) - assert raises(lambda: g.discrete_log(a), ValueError) - - # Need to use either fmpz_mod or something which can be case to - # fmpz - assert raises(lambda: g.discrete_log("A"), TypeError) # type: ignore - - F = fmpz_mod_ctx(163) - g = F(2) - a = g**123 - - assert 123 == g.discrete_log(a) - - a_int = pow(2, 123, 163) - a_fmpz = fmpz(a_int) - assert 123 == g.discrete_log(a_int) - assert 123 == g.discrete_log(a_fmpz) - - # Randomised testing with smooth large modulus - e2, e3 = 92, 79 - p = 2**e2 * 3**e3 + 1 - F = fmpz_mod_ctx(p) - - for _ in range(10): - g = F(random.randint(1,p-1)) - for _ in range(10): - i = random.randint(0,p) - a = g**i - x = g.discrete_log(a) - assert g**x == a - -def test_fmpz_mod_poly(): - from flint import fmpz_poly, fmpz_mod_poly, fmpz_mod_poly_ctx, fmpz_mod_ctx, fmpz - - # fmpz_mod_poly_ctx tests - F = fmpz_mod_ctx(11) - R1 = fmpz_mod_poly_ctx(F) - R2 = fmpz_mod_poly_ctx(11) - R3 = fmpz_mod_poly_ctx(13) - - assert raises(lambda: fmpz_mod_ctx("AAA"), TypeError) # type: ignore - assert raises(lambda: fmpz_mod_ctx(-1), ValueError) - assert (R1 == R1) is True - assert (R1 != R1) is False - assert (R1 == R2) is True - assert (R1 != R2) is False - assert (R1 != R3) is True - assert (R1 == R3) is False - assert (R1 != "AAA") is True - assert (R1 == "AAA") is False - - assert (hash(R1) == hash(R1)) is True - assert (hash(R1) == hash(R2)) is True - assert (hash(R1) != hash(R3)) is True - - assert str(R1) == "Context for fmpz_mod_poly with modulus: 11" - assert str(R1) == str(R2) - assert repr(R3) == "fmpz_mod_poly_ctx(13)" - - assert R1.modulus() == 11 - - assert R1.is_prime() - assert R1.zero() == 0 - assert R1.one() == 1 - assert R1.gen() == R1([0,1]) - - # Random testing - f = R1.random_element() - assert f.degree() <= 3 - f = R1.random_element(degree=5, monic=True) - assert f.degree() == 5 - assert f.is_monic() - f = R1.random_element(degree=100, irreducible=True) - assert f.degree() <= 100 - assert f.is_irreducible() - f = R1.random_element(degree=1, monic=True, irreducible=True) - assert f.degree() == 1 - assert f.is_irreducible() - assert f.is_monic() - assert raises(lambda: R1.random_element(degree=-123), ValueError) - assert raises(lambda: R1.random_element(monic="A"), TypeError) # type: ignore - assert raises(lambda: R1.random_element(irreducible="A"), TypeError) # type: ignore - - # Conversion tests - F = fmpz_mod_ctx(11) - F_other = fmpz_mod_ctx(10) - R = fmpz_mod_poly_ctx(F) - R_other = fmpz_mod_poly_ctx(F_other) - - assert raises(lambda: fmpz_mod_poly(1, "A"), TypeError) # Need a valid context - assert raises(lambda: R(R_other([1,2,3])), ValueError) # moduli must match - assert raises(lambda: R(F_other(2)), ValueError) # moduli must match - assert raises(lambda: R([F(1), F_other(2)]), ValueError) # moduli must match - assert raises(lambda: R([F(1), "A"]), TypeError) # type: ignore - - R.__call__ - f1 = R([-1, -2, -3]) - f2 = R([fmpz(-1),fmpz(-2),fmpz(-3)]) - f3 = R([F(-1),F(-2),F(-3)]) - f4 = R(fmpz_poly([-1, -2, -3])) - f5 = R(f4) - - assert str(f1) == "8*x^2 + 9*x + 10" - assert str(f2) == "8*x^2 + 9*x + 10" - assert str(f3) == "8*x^2 + 9*x + 10" - assert str(f4) == "8*x^2 + 9*x + 10" - assert str(f5) == "8*x^2 + 9*x + 10" - - f1 = R(5) - f2 = R(fmpz(6)) - f3 = R(F(7)) - assert str(f1) == "5" - assert str(f2) == "6" - assert str(f3) == "7" - - # Printing - f = R([5, 6, 7, 8]) - assert str(f) == "8*x^3 + 7*x^2 + 6*x + 5" - # assert repr(f) == "fmpz_mod_poly([5, 6, 7, 8], fmpz_mod_poly_ctx(11))" - - # Get and Set tests - f = R([5, 6, 7, 8]) - assert f[0] == 5 - assert repr(f[0]) == "fmpz_mod(5, 11)" - f[0] = 7 - assert repr(f[0]) == "fmpz_mod(7, 11)" - assert str(f) == "8*x^3 + 7*x^2 + 6*x + 7" - - # TODO: currently repr does pretty printing - # just like str, we should address this. Mainly, - # the issue is we want nice `repr` behaviour in - # interactive shells, which currently is why this - # choice has been made - assert str(f) == repr(f) - - assert f[-1] == 0 - assert raises(lambda: f.__setitem__(-1, 1), ValueError) - assert raises(lambda: f.__setitem__(1, "A"), TypeError) # type: ignore - - # Comparisons - f1 = R([1,2,3]) - f2 = R([12,13,14]) - f3 = R([4,5,6]) - f4 = R([3]) - - assert (f1 == f2) is True - assert (f1 != f3) is True - assert (f1 != "1") is True - assert (f4 == 3) is True - assert (hash(f1) == hash(f2)) is True - assert raises(lambda: f1 > f2, TypeError) # type: ignore - assert raises(lambda: f1 >= f2, TypeError) # type: ignore - assert raises(lambda: f1 < f2, TypeError) # type: ignore - assert raises(lambda: f1 <= f2, TypeError) # type: ignore - - assert len(f1) == f1.length() == 3 - assert f1.degree() == 2 - - f1 = R([0]) - f2 = R([1]) - f3 = R([0, 1]) - - assert f1.is_zero() is True - assert f2.is_one() is True - assert f3.is_gen() is True - - # Arithmetic - p_sml = 163 - p_med = 2**127 - 1 - p_big = 2**255 - 19 - - F_sml = fmpz_mod_ctx(p_sml) - F_med = fmpz_mod_ctx(p_med) - F_big = fmpz_mod_ctx(p_big) - - R_sml = fmpz_mod_poly_ctx(F_sml) - R_med = fmpz_mod_poly_ctx(F_med) - R_big = fmpz_mod_poly_ctx(F_big) - - F_cmp = fmpz_mod_ctx(10) - R_cmp = fmpz_mod_poly_ctx(F_cmp) - f_cmp = R_cmp([1,2,3,4,5]) - f_bad = R_cmp([2,2,2,2,2]) - - for (F_test, R_test) in [(F_sml, R_sml), (F_med, R_med), (F_big, R_big)]: - - f = R_test([-1,-2]) - g = R_test([-3,-4]) - - # pos, neg - assert f is +f - assert -f == R_test([1,2]) - - # add - assert raises(lambda: f + f_cmp, ValueError) - assert raises(lambda: f + "AAA", TypeError) # type: ignore - assert raises(lambda: "AAA" + f, TypeError) # type: ignore - assert f + g == R_test([-4,-6]) - assert f + 1 == R_test([0,-2]) - assert f + fmpz(1) == R_test([0,-2]) - assert f + F_test(1) == R_test([0,-2]) - assert 1 + f == R_test([0,-2]) - assert fmpz(1) + f == R_test([0,-2]) - assert F_test(1) + f == R_test([0,-2]) - - # sub - assert raises(lambda: f - f_cmp, ValueError) - assert raises(lambda: f - "AAA", TypeError) # type: ignore - assert raises(lambda: "AAA" - f, TypeError) # type: ignore - assert f - g == R_test([2, 2]) - assert f - 1 == R_test([-2,-2]) - assert f - fmpz(1) == R_test([-2,-2]) - assert f - F_test(1) == R_test([-2,-2]) - assert 1 - f == R_test([2, 2]) - assert fmpz(1) - f == R_test([2, 2]) - assert F_test(1) - f == R_test([2, 2]) - - # mul - assert raises(lambda: f * f_cmp, ValueError) - assert raises(lambda: f * "AAA", TypeError) # type: ignore - assert raises(lambda: "AAA" * f, TypeError) # type: ignore - assert f * g == R_test([3, 4 + 6, 8]) - assert f * 2 == R_test([-2,-4]) - assert f * fmpz(2) == R_test([-2,-4]) - assert f * F_test(2) == R_test([-2,-4]) - assert 2 * f == R_test([-2,-4]) - assert fmpz(2) * f == R_test([-2,-4]) - assert F_test(2) * f == R_test([-2,-4]) - - # scalar_mul - assert 2 * f == f.scalar_mul(2) - assert raises(lambda: f.scalar_mul("AAA"), TypeError) # type: ignore - - # Exact division - assert raises(lambda: f.exact_division(f_cmp), ValueError) - assert raises(lambda: f.exact_division("AAA"), TypeError) # type: ignore - assert raises(lambda: f.exact_division(0), ZeroDivisionError) - - assert (f * g).exact_division(g) == f - assert raises(lambda: f.exact_division(g), DomainError) - - # true div - assert raises(lambda: f / "AAA", TypeError) # type: ignore - assert raises(lambda: f / 0, ZeroDivisionError) - assert raises(lambda: f_cmp / 2, DomainError) - - assert (f + f) / 2 == f - assert (f + f) / fmpz(2) == f - assert (f + f) / F_test(2) == f - - # floor div - assert raises(lambda: 1 // f_bad, DomainError) - assert raises(lambda: f // f_cmp, ValueError) - assert raises(lambda: f // "AAA", TypeError) # type: ignore - assert raises(lambda: "AAA" // f, TypeError) # type: ignore - assert (f * g) // g == f - assert (f + f) // 2 == f - assert (f + f) // fmpz(2) == f - assert (f + f) // F_test(2) == f - assert 2 // R_test(2) == 1 - assert (f + 1) // f == 1 - - # pow - assert raises(lambda: f**(-2), DomainError) - assert f*f == f**2 - assert f*f == f**fmpz(2) - - # pow_mod - # assert ui and fmpz exp agree for polynomials and generators - R_gen = R_test.gen() - assert pow(f, 2**60, g) == pow(pow(f, 2**30, g), 2**30, g) - assert pow(R_gen, 2**60, g) == pow(pow(R_gen, 2**30, g), 2**30, g) - - # Check other typechecks for pow_mod - assert raises(lambda: pow(f, -2, g), ValueError) - assert raises(lambda: pow(f, 1, "A"), TypeError) # type: ignore - assert raises(lambda: pow(f, "A", g), TypeError) # type: ignore - assert raises(lambda: f.pow_mod(2**32, g, mod_rev_inv="A"), TypeError) # type: ignore - - # Shifts - assert raises(lambda: R_test([1,2,3]).left_shift(-1), ValueError) - assert raises(lambda: R_test([1,2,3]).right_shift(-1), ValueError) - assert R_test([1,2,3]).left_shift(3) == R_test([0,0,0,1,2,3]) - assert R_test([1,2,3]).right_shift(1) == R_test([2,3]) - - # Mod - assert raises(lambda: f % f_bad, ValueError) - assert raises(lambda: 123 % f_bad, DomainError) - assert raises(lambda: f % "AAA", TypeError) # type: ignore - assert raises(lambda: tuple() % f, TypeError) # type: ignore - - assert f % 1 == 0 - assert R_test.one() % 1 == 0 - assert 100 % R_test.one() == 0 - assert (f*g + 1) % f == 1 - assert (f*g + g) % f == (g % f) - assert f % R_test([0,1]) == f.constant_coefficient() - - # Evaluation - h = R_test([0, 1]) - assert h(1) == 1 - assert h(-1) == R_test.modulus() - 1 - h = R_test([0, 0, 1]) - assert h(1) == h(-1) - assert raises(lambda: h("AAA"), TypeError) # type: ignore - assert f([-1,-2,-3]) == [f(x) for x in [-1, -2, -3]] - - # compose - assert raises(lambda: h.compose("AAA"), TypeError) # type: ignore - - # compose mod - mod = R_test([1,2,3,4]) - assert f.compose(h) % mod == f.compose_mod(h, mod) - assert raises(lambda: h.compose_mod("AAA", mod), TypeError) # type: ignore - assert raises(lambda: h.compose_mod(f, "AAA"), TypeError) # type: ignore - assert raises(lambda: h.compose_mod(f, R_test(0)), ZeroDivisionError) - - # Reverse - assert raises(lambda: h.reverse(degree=-100), ValueError) - assert R_test([-1,-2,-3]).reverse() == R_test([-3,-2,-1]) - - # monic - assert raises(lambda: f_bad.monic(), ValueError) - assert R_test([1,2]).monic() == R_test([1 / F_test(2), 1]) - assert R_test([1,2]).monic(check=False) == R_test([1 / F_test(2), 1]) - - # Square - assert f*f == f**2 == f.square() - - # mulmod - assert f.mul_mod(f, g) == (f*f) % g - assert raises(lambda: f.mul_mod(f, "AAA"), TypeError) # type: ignore - assert raises(lambda: f.mul_mod("AAA", g), TypeError) # type: ignore - - # pow_mod - assert f.pow_mod(2, g) == (f*f) % g - assert raises(lambda: f.pow_mod(2, "AAA"), TypeError) # type: ignore - - # divmod - S, T = f.divmod(g) - assert S*g + T == f - assert raises(lambda: f.divmod("AAA"), TypeError) # type: ignore - assert raises(lambda: f_bad.divmod(f_bad), ValueError) - - # gcd - assert raises(lambda: f_cmp.gcd(f_cmp), DomainError) - assert raises(lambda: f.gcd("f"), TypeError) # type: ignore - - # xgcd - assert raises(lambda: (f_cmp).xgcd(f_cmp), ValueError) - assert raises(lambda: (f).xgcd("f_cmp"), TypeError) # type: ignore - - # disc. - assert raises(lambda: (f_cmp).discriminant(), NotImplementedError) - - # Radical - assert raises(lambda: (f_cmp).radical(), NotImplementedError) - - # inverse_mod - f_inv = f.inverse_mod(g) - assert (f * f_inv) % g == 1 - assert raises(lambda: f.inverse_mod("AAA"), TypeError) # type: ignore - assert raises(lambda: (f_cmp).inverse_mod(f_cmp), ValueError) - - f_inv = f.inverse_series_trunc(2) - assert (f * f_inv) % R_test([0,0,1]) == 1 - assert raises(lambda: R_cmp([0,0,1]).inverse_series_trunc(2), ValueError) - - # Resultant - f1 = R_test([-3, 1]) - f2 = R_test([-5, 1]) - assert f1.resultant(f2) == (3 - 5) - assert raises(lambda: f.resultant("AAA"), TypeError) # type: ignore - - # sqrt - f1 = R_test.random_element(irreducible=True) - assert raises(lambda: f1.sqrt(), DomainError) - assert (f1*f1).sqrt() in [f1, -f1] - - # deflation - f1 = R_test([1,0,2,0,3]) - assert raises(lambda: f1.deflate(100), ValueError) - assert f1.deflate(2) == R_test([1,2,3]) - - # factor - ff = R_test([3,2,1]) * R_test([3,2,1]) * R_test([5,4,3]) - ff_rebuild = R_test.one() - c, facs = ff.factor() - ff_rebuild *= c - for p, e in facs: - assert p.is_irreducible() - ff_rebuild *= p**e - assert ff_rebuild == ff - - assert set(ff.factor()[1]) == set(ff.factor(algorithm="cantor_zassenhaus")[1]) - assert set(ff.factor()[1]) == set(ff.factor(algorithm="kaltofen_shoup")[1]) - assert set(ff.factor()[1]) == set(ff.factor(algorithm="berlekamp")[1]) - assert raises(lambda: R_test([0,0,1]).factor(algorithm="AAA"), ValueError) - assert raises(lambda: R_test([0,0,1]).real_roots(), DomainError) - assert raises(lambda: R_test([0,0,1]).complex_roots(), DomainError) - - # composite moduli not supported - assert raises(lambda: R_cmp([0,0,1]).factor(), DomainError) - assert raises(lambda: R_cmp([0,0,1]).factor_squarefree(), DomainError) - assert raises(lambda: R_cmp([0,0,1]).roots(), NotImplementedError) - assert raises(lambda: R_cmp([0,0,1]).real_roots(), DomainError) - assert raises(lambda: R_cmp([0,0,1]).complex_roots(), DomainError) - - # minpoly - assert raises(lambda: R_cmp.minpoly([1,2,3,4]), NotImplementedError) - assert raises(lambda: R_test.minpoly(1), TypeError) # type: ignore - assert raises(lambda: R_test.minpoly([1,2,3,"AAA"]), TypeError) # type: ignore - - # multipoint_evaluation - assert raises(lambda: R_test([1,2,3]).multipoint_evaluate([1,2,3,"AAA"]), TypeError) # type: ignore - assert raises(lambda: R_test([1,2,3]).multipoint_evaluate("AAA"), TypeError) # type: ignore - - f = R_test([1,2,3]) - ell = [-1,-2,-3,-4,-5] - assert [f(x) for x in ell] == f.multipoint_evaluate(ell) - - # truncate things - - f = R_test.random_element() - g = R_test.random_element() - h = R_test.random_element() - x = R_test.gen() - - f_trunc = f % x**3 - - assert f.equal_trunc(f_trunc, 3) - assert not f.equal_trunc("A", 3) - assert not f.equal_trunc(f_cmp, 3) - - assert raises(lambda: f.add_trunc("A", 1), TypeError) # type: ignore - assert raises(lambda: f.add_trunc(f_cmp, 1), ValueError) - assert f.add_trunc(g, 3) == (f + g) % x**3 - - assert raises(lambda: f.sub_trunc("A", 1), TypeError) # type: ignore - assert raises(lambda: f.sub_trunc(f_cmp, 1), ValueError) - assert f.sub_trunc(g, 3) == (f - g) % x**3 - - assert raises(lambda: f.mul_low("A", h), TypeError) # type: ignore - assert raises(lambda: f.mul_low(g, "A"), TypeError) # type: ignore - assert f.mul_low(g, 3) == (f * g) % x**3 - - assert raises(lambda: f.pow_trunc(-1, 5), ValueError) - - -def test_fmpz_mod_mat(): - c11 = flint.fmpz_mod_ctx(11) - c13 = flint.fmpz_mod_ctx(13) - - M11_1 = flint.fmpz_mod_mat([[1,2,3],[4,5,6],[7,8,9]], c11) - M11_2 = flint.fmpz_mod_mat([[1,2,3],[4,5,6],[7,8,9]], c11) - M13 = flint.fmpz_mod_mat([[1,2,3],[4,5,6],[7,8,9]], c13) - assert (M11_1 == M11_2) is True - assert (M11_1 != M11_2) is False - assert (M11_1 == M13) is False - assert (M11_1 != M13) is True - - Mn_11 = flint.nmod_mat([[1,2,3],[4,5,6],[7,8,9]], 11) - Mn_13 = flint.nmod_mat([[1,2,3],[4,5,6],[7,8,9]], 13) - assert (M11_1 == Mn_11) is True - assert (M11_1 != Mn_11) is False - assert (M11_1 == Mn_13) is False - assert (M11_1 != Mn_13) is True - assert (Mn_11 == M11_1) is True - assert (Mn_11 != M11_1) is False - assert (Mn_13 == M11_1) is False - assert (Mn_13 != M11_1) is True - - M = flint.fmpz_mod_mat([[1,2,3],[4,5,6],[7,8,9]], c11) - assert M.nrows() == 3 - assert M.ncols() == 3 - assert M.entries() == [flint.fmpz_mod(i, c11) for i in [1,2,3,4,5,6,7,8,9]] - assert isinstance(M[0,0], flint.fmpz_mod) - assert M[0,0] == 1 - assert raises(lambda: flint.fmpz_mod_mat([[1]]), TypeError) - assert raises(lambda: flint.fmpz_mod_mat([[1,2],[3,4]], c11, c11), TypeError) - assert raises(lambda: flint.fmpz_mod_mat([[1,2],[3,4]], None), TypeError) - - M11 = flint.fmpz_mod_mat([[1,2,3],[4,5,6],[7,8,9]], c11) - M13 = flint.fmpz_mod_mat([[1,2,3],[4,5,6],[7,8,9]], c13) - Mz = flint.fmpz_mat([[1,2,3],[4,5,6],[7,8,9]]) - Mn_11 = flint.nmod_mat([[1,2,3],[4,5,6],[7,8,9]], 11) - Mn_13 = flint.nmod_mat([[1,2,3],[4,5,6],[7,8,9]], 13) - assert raises(lambda: flint.fmpz_mod_mat(Mz), TypeError) - assert flint.fmpz_mod_mat(Mz, c11) == M11 - assert flint.fmpz_mod_mat(Mz, c13) == M13 - assert flint.fmpz_mod_mat(Mn_11) == M11 - assert flint.fmpz_mod_mat(Mn_13) == M13 - assert flint.fmpz_mod_mat(Mn_11, c11) == M11 - assert flint.fmpz_mod_mat(Mn_13, c13) == M13 - assert raises(lambda: flint.fmpz_mod_mat(Mn_11, c13), TypeError) - assert raises(lambda: flint.fmpz_mod_mat(Mn_13, c11), TypeError) - assert flint.fmpz_mod_mat(M11) == M11 - assert flint.fmpz_mod_mat(M13) == M13 - assert flint.fmpz_mod_mat(M11, c11) == M11 - assert flint.fmpz_mod_mat(M13, c13) == M13 - assert raises(lambda: flint.fmpz_mod_mat(M11, c13), TypeError) - assert raises(lambda: flint.fmpz_mod_mat(M13, c11), TypeError) - - A = flint.arb_mat([[1,2,3],[4,5,6],[7,8,9]]) - assert raises(lambda: flint.fmpz_mod_mat(A, c11), TypeError) - - -def test_division_scalar(): - Z = flint.fmpz - Q = flint.fmpq - F17 = lambda x: flint.nmod(x, 17) - ctx = flint.fmpz_mod_ctx(163) - F163 = lambda a: flint.fmpz_mod(a, ctx) - # fmpz exact division - for (a, b) in [(Z(4), Z(2)), (Z(4), 2), (4, Z(2))]: - assert a / b == Z(2) - for (a, b) in [(Z(5), Z(2)), (Z(5), 2), (5, Z(2))]: - assert raises(lambda: a / b, DomainError) - # fmpz Euclidean division - for (a, b) in [(Z(5), Z(2)), (Z(5), 2), (5, Z(2))]: - assert a // b == 2 - assert a % b == 1 - assert divmod(a, b) == (2, 1) - # field division - for (a, b) in [(Q(5), Q(2)), (Q(5), 2), (5, Q(2))]: - assert a / b == Q(5,2) - for (a, b) in [(F17(5), F17(2)), (F17(5), 2), (5, F17(2))]: - assert a / b == F17(11) - for (a, b) in [(F163(5), F163(2)), (F163(5), 2), (5, F163(2))]: - assert a / b == F163(84) - # divmod with fields - should this give remainder zero instead of error? - for K in [Q, F17, F163]: - for (a, b) in [(K(5), K(2)), (K(5), 2), (5, K(2))]: - assert raises(lambda: divmod(a, b), TypeError) - # Zero division - for R in [Z, Q, F17, F163]: - assert raises(lambda: R(5) / 0, ZeroDivisionError) - assert raises(lambda: R(5) / R(0), ZeroDivisionError) - assert raises(lambda: 5 / R(0), ZeroDivisionError) - # Bad types - for R in [Z, Q, F17, F163]: - assert raises(lambda: R(5) / "AAA", TypeError) - assert raises(lambda: "AAA" / R(5), TypeError) - - -def test_division_poly(): - Z = flint.fmpz - Q = flint.fmpq - F17 = lambda x: flint.nmod(x, 17) - ctx = flint.fmpz_mod_ctx(163) - F163 = lambda a: flint.fmpz_mod(a, ctx) - PZ = lambda x: flint.fmpz_poly(x) - PQ = lambda x: flint.fmpq_poly(x) - PF17 = lambda x: flint.nmod_poly(x, 17) - PF163 = lambda x: flint.fmpz_mod_poly(x, flint.fmpz_mod_poly_ctx(163)) - # fmpz exact scalar division - assert PZ([2, 4]) / Z(2) == PZ([1, 2]) - assert PZ([2, 4]) / 2 == PZ([1, 2]) - assert raises(lambda: PZ([2, 5]) / Z(2), DomainError) - assert raises(lambda: PZ([2, 5]) / 2, DomainError) - # field division by scalar - for (K, PK) in [(Q, PQ), (F17, PF17), (F163, PF163)]: - assert PK([2, 5]) / K(2) == PK([K(2)/K(2), K(5)/K(2)]) - assert PK([2, 5]) / 2 == PK([K(2)/K(2), K(5)/K(2)]) - # No other scalar division is allowed - for (R, PR) in [(Z, PZ), (Q, PQ), (F17, PF17), (F163, PF163)]: - assert raises(lambda: R(2) / PR([2, 5]), DomainError) - assert raises(lambda: 2 / PR([2, 5]), DomainError) - assert raises(lambda: PR([2, 5]) / 0, ZeroDivisionError) - assert raises(lambda: PR([2, 5]) / R(0), ZeroDivisionError) - # exact polynomial division - for (R, PR) in [(Z, PZ), (Q, PQ), (F17, PF17), (F163, PF163)]: - assert PR([2, 4]) / PR([1, 2]) == PR([2]) - assert PR([2, -3, 1]) / PR([-1, 1]) == PR([-2, 1]) - assert raises(lambda: PR([2, 4]) / PR([1, 3]), DomainError) - assert PR([2]) / PR([2]) == 2 / PR([2]) == PR([1]) - assert PR([0]) / PR([1, 2]) == 0 / PR([1, 2]) == PR([0]) - if R is Z: - assert raises(lambda: PR([1, 2]) / PR([2, 4]), DomainError) - assert raises(lambda: 1 / PR([2]), DomainError) - else: - assert PR([1, 2]) / PR([2, 4]) == PR([R(1)/R(2)]) - assert 1 / PR([2]) == PR([R(1)/R(2)]) - assert raises(lambda: PR([1, 2]) / PR([0]), ZeroDivisionError) - # Euclidean polynomial division - for (R, PR) in [(Z, PZ), (Q, PQ), (F17, PF17), (F163, PF163)]: - assert PR([2, 4]) // PR([1, 2]) == PR([2]) - assert PR([2, 4]) % PR([1, 2]) == PR([0]) - assert divmod(PR([2, 4]), PR([1, 2])) == (PR([2]), PR([0])) - assert PR([3, -3, 1]) // PR([-1, 1]) == PR([-2, 1]) - assert PR([3, -3, 1]) % PR([-1, 1]) == PR([1]) - assert divmod(PR([3, -3, 1]), PR([-1, 1])) == (PR([-2, 1]), PR([1])) - assert PR([2]) // PR([2]) == 2 // PR([2]) == PR([1]) - assert PR([2]) % PR([2]) == 2 % PR([2]) == PR([0]) - assert divmod(PR([2]), PR([2])) == (PR([1]), PR([0])) - assert PR([0]) // PR([1, 2]) == 0 // PR([1, 2]) == PR([0]) - assert PR([0]) % PR([1, 2]) == 0 % PR([1, 2]) == PR([0]) - assert divmod(PR([0]), PR([1, 2])) == (PR([0]), PR([0])) - if R is Z: - assert PR([2, 2]) // PR([2, 4]) == PR([2, 2]) // PR([2, 4]) == PR([0]) - assert PR([2, 2]) % PR([2, 4]) == PR([2, 2]) % PR([2, 4]) == PR([2, 2]) - assert divmod(PR([2, 2]), PR([2, 4])) == (PR([0]), PR([2, 2])) - assert 1 // PR([2]) == PR([1]) // PR([2]) == PR([0]) - assert 1 % PR([2]) == PR([1]) % PR([2]) == PR([1]) - assert divmod(1, PR([2])) == (PR([0]), PR([1])) - else: - assert PR([2, 2]) // PR([2, 4]) == PR([R(1)/R(2)]) - assert PR([2, 2]) % PR([2, 4]) == PR([1]) - assert divmod(PR([2, 2]), PR([2, 4])) == (PR([R(1)/R(2)]), PR([1])) - assert 1 // PR([2]) == PR([R(1)/R(2)]) - assert 1 % PR([2]) == PR([0]) - assert divmod(1, PR([2])) == (PR([R(1)/R(2)]), PR([0])) - - -def test_division_matrix(): - Z = flint.fmpz - Q = flint.fmpq - F17 = lambda x: flint.nmod(x, 17) - ctx = flint.fmpz_mod_ctx(163) - F163 = lambda a: flint.fmpz_mod(a, ctx) - MZ = lambda x: flint.fmpz_mat(x) - MQ = lambda x: flint.fmpq_mat(x) - MF17 = lambda x: flint.nmod_mat(x, 17) - MF163 = lambda x: flint.fmpz_mod_mat(x, ctx) - # fmpz exact division - assert MZ([[2, 4]]) / Z(2) == MZ([[1, 2]]) - assert MZ([[2, 4]]) / 2 == MZ([[1, 2]]) - assert raises(lambda: MZ([[2, 5]]) / Z(2), DomainError) - assert raises(lambda: MZ([[2, 5]]) / 2, DomainError) - # field division by scalar - for (K, MK) in [(Q, MQ), (F17, MF17), (F163, MF163)]: - assert MK([[2, 5]]) / K(2) == MK([[K(2)/K(2), K(5)/K(2)]]) - assert MK([[2, 5]]) / 2 == MK([[K(2)/K(2), K(5)/K(2)]]) - # No other division is allowed - for (R, MR) in [(Z, MZ), (Q, MQ), (F17, MF17), (F163, MF163)]: - M = MR([[2, 5]]) - for s in (2, R(2)): - assert raises(lambda: s / M, TypeError) - assert raises(lambda: M // s, TypeError) - assert raises(lambda: s // M, TypeError) - assert raises(lambda: M % s, TypeError) - assert raises(lambda: s % M, TypeError) - assert raises(lambda: divmod(s, M), TypeError) - assert raises(lambda: divmod(M, s), TypeError) - assert raises(lambda: M / M, TypeError) - assert raises(lambda: M // M, TypeError) - assert raises(lambda: M % M, TypeError) - assert raises(lambda: divmod(M, M), TypeError) - assert raises(lambda: M / 0, ZeroDivisionError) - assert raises(lambda: M / R(0), ZeroDivisionError) - - -def _all_polys() -> list[tuple[Any, Any, bool, flint.fmpz]]: - return [ - # (poly_type, scalar_type, is_field, characteristic) - - # Z and Q - (flint.fmpz_poly, flint.fmpz, False, flint.fmpz(0)), - (flint.fmpq_poly, flint.fmpq, True, flint.fmpz(0)), - - # Z/pZ (p prime) - (lambda *a: flint.nmod_poly(*a, 17), lambda x: flint.nmod(x, 17), True, flint.fmpz(17)), - (lambda *a: flint.fmpz_mod_poly(*a, flint.fmpz_mod_poly_ctx(163)), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(163)), - True, flint.fmpz(163)), - (lambda *a: flint.fmpz_mod_poly(*a, flint.fmpz_mod_poly_ctx(2**127 - 1)), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(2**127 - 1)), - True, flint.fmpz(2**127 - 1)), - (lambda *a: flint.fmpz_mod_poly(*a, flint.fmpz_mod_poly_ctx(2**255 - 19)), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(2**255 - 19)), - True, flint.fmpz(2**255 - 19)), - - # GF(p^k) (p prime) - (lambda *a: flint.fq_default_poly(*a, flint.fq_default_poly_ctx(2**127 - 1)), - lambda x: flint.fq_default(x, flint.fq_default_ctx(2**127 - 1)), - True, flint.fmpz(2**127 - 1)), - (lambda *a: flint.fq_default_poly(*a, flint.fq_default_poly_ctx(2**127 - 1, 2)), - lambda x: flint.fq_default(x, flint.fq_default_ctx(2**127 - 1, 2)), - True, flint.fmpz(2**127 - 1)), - (lambda *a: flint.fq_default_poly(*a, flint.fq_default_poly_ctx(65537)), - lambda x: flint.fq_default(x, flint.fq_default_ctx(65537)), - True, flint.fmpz(65537)), - (lambda *a: flint.fq_default_poly(*a, flint.fq_default_poly_ctx(65537, 5)), - lambda x: flint.fq_default(x, flint.fq_default_ctx(65537, 5)), - True, flint.fmpz(65537)), - (lambda *a: flint.fq_default_poly(*a, flint.fq_default_poly_ctx(11)), - lambda x: flint.fq_default(x, flint.fq_default_ctx(11)), - True, flint.fmpz(11)), - (lambda *a: flint.fq_default_poly(*a, flint.fq_default_poly_ctx(11, 5)), - lambda x: flint.fq_default(x, flint.fq_default_ctx(11, 5)), - True, flint.fmpz(11)), - - # Z/nZ (n composite) - (lambda *a: flint.nmod_poly(*a, 16), lambda x: flint.nmod(x, 16), False, flint.fmpz(16)), - (lambda *a: flint.fmpz_mod_poly(*a, flint.fmpz_mod_poly_ctx(164)), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(164)), - False, flint.fmpz(164)), - (lambda *a: flint.fmpz_mod_poly(*a, flint.fmpz_mod_poly_ctx(2**127)), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(2**127)), - False, flint.fmpz(2**127)), - (lambda *a: flint.fmpz_mod_poly(*a, flint.fmpz_mod_poly_ctx(2**255)), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(2**255)), - False, flint.fmpz(2**255)), - ] - - -Tpoly = TypeVar("Tpoly", bound=typ.epoly_p) -Tc = TypeVar("Tc", bound=typ.scalar_p) -TS = Callable[[Tc | int], Tc] -TP = Callable[[Tpoly | Sequence[Tc | int] | Tc | int], Tpoly] -_PolyTestCase = tuple[TP[Tpoly,Tc], TS[Tc], bool, flint.fmpz] - - -def _for_all_polys(test: Callable[[_PolyTestCase], None]) -> None: - """Test all mpoly types with the given test function.""" - # Spell it out like this so that a type checker can understand the types - # in the generics for each call of test(). - - fmpz: TS[flint.fmpz] = flint.fmpz - fmpq: TS[flint.fmpq] = flint.fmpq - fmpz_poly: TP[flint.fmpz_poly, flint.fmpz] = flint.fmpz_poly - fmpq_poly: TP[flint.fmpq_poly, flint.fmpq] = flint.fmpq_poly - - def nmod_poly( - p: int, - ) -> tuple[TP[flint.nmod_poly, flint.nmod], TS[flint.nmod]]: - """Make nmod poly and scalar constructors for modulus p.""" - - def poly( - x: Sequence[flint.nmod | int] | flint.nmod_poly | flint.nmod | int, / - ) -> flint.nmod_poly: - return flint.nmod_poly(x, p) - - def elem(x: int | flint.nmod = 0, /) -> flint.nmod: - return flint.nmod(x, p) - - return poly, elem - - def fmpz_mod_poly( - p: int, - ) -> tuple[TP[flint.fmpz_mod_poly, flint.fmpz_mod], TS[flint.fmpz_mod]]: - """Make fmpz_mod poly and scalar constructors for modulus p.""" - ectx = flint.fmpz_mod_ctx(p) - pctx = flint.fmpz_mod_poly_ctx(ectx) - - def poly( - x: Sequence[flint.fmpz_mod | int] - | flint.fmpz_mod_poly - | flint.fmpz_mod - | int, - /, - ) -> flint.fmpz_mod_poly: - return flint.fmpz_mod_poly(x, pctx) - - def elem(x: int | flint.fmpz_mod = 0, /) -> flint.fmpz_mod: - return flint.fmpz_mod(x, ectx) - - return poly, elem - - def fq_default_poly( - p: int, k: int | None = None - ) -> tuple[ - TP[flint.fq_default_poly, flint.fq_default], TS[flint.fq_default] - ]: - """Make fq_default poly and scalar constructors for field p^k.""" - if k is None: - ectx = flint.fq_default_ctx(p) - else: - ectx = flint.fq_default_ctx(p, k) - pctx = flint.fq_default_poly_ctx(ectx) - - def poly( - x: Sequence[flint.fq_default | int] - | flint.fq_default_poly - | flint.fq_default - | int, - /, - ) -> flint.fq_default_poly: - return flint.fq_default_poly(x, pctx) - - def elem(x: int | flint.fq_default = 0, /) -> flint.fq_default: - return flint.fq_default(x, ectx) - - return poly, elem - - # Z and Q - test((fmpz_poly, fmpz, False, flint.fmpz(0))) - test((fmpq_poly, fmpq, True, flint.fmpz(0))) - - # Z/pZ (p prime) - test((*nmod_poly(17), True, flint.fmpz(17))) - test((*fmpz_mod_poly(163), True, flint.fmpz(163))) - test((*fmpz_mod_poly(2**127 - 1), True, flint.fmpz(2**127 - 1))) - test((*fmpz_mod_poly(2**255 - 19), True, flint.fmpz(2**255 - 19))) - - # Z/nZ (n composite) - test((*nmod_poly(16), False, flint.fmpz(16))) - test((*fmpz_mod_poly(164), False, flint.fmpz(164))) - test((*fmpz_mod_poly(2**127), False, flint.fmpz(2**127))) - test((*fmpz_mod_poly(2**255), False, flint.fmpz(2**255))) - - # GF(p^k) - test((*fq_default_poly(2**127 - 1), True, flint.fmpz(2**127 - 1))) - test((*fq_default_poly(2**127 - 1, 2), True, flint.fmpz(2**127 - 1))) - test((*fq_default_poly(65537), True, flint.fmpz(65537))) - test((*fq_default_poly(65537, 5), True, flint.fmpz(65537))) - test((*fq_default_poly(11), True, flint.fmpz(11))) - test((*fq_default_poly(11, 5), True, flint.fmpz(11))) - - -def all_polys(f: Callable[[_PolyTestCase], None]) -> Callable[[], None]: - """Decorator to run a test function for all mpoly types.""" - def wrapper(): - _for_all_polys(f) - wrapper.__name__ = f.__name__ - return wrapper - - -@all_polys -def test_polys(args: _PolyTestCase[typ.epoly_p[Tc], Tc]) -> None: - # To test type annotations, uncomment: - # P: type[flint.fmpq_poly] - # S: type[flint.fmpq] - # is_field: bool - # characteristic: flint.fmpz - P, S, is_field, characteristic = args - - composite_characteristic = characteristic != 0 and not characteristic.is_prime() - # nmod_poly crashes for many operations with non-prime modulus - # https://github.com/flintlib/python-flint/issues/124 - # so we can't even test it... - nmod_poly_will_crash = type(P(1)) is flint.nmod_poly and composite_characteristic - - assert P([S(1)]) == P([1]) == P(P([1])) == P(1) - - assert raises(lambda: P([None]), TypeError) # type: ignore - assert raises(lambda: P(object()), TypeError) # type: ignore - assert raises(lambda: P(None), TypeError) # type: ignore - assert raises(lambda: P(None, None), TypeError) # type: ignore - assert raises(lambda: P([1,2], None), TypeError) # type: ignore - assert raises(lambda: P(1, None), TypeError) # type: ignore - - assert len(P([])) == P([]).length() == 0 - assert len(P([1])) == P([1]).length() == 1 - assert len(P([1,2])) == P([1,2]).length() == 2 - assert len(P([1,2,3])) == P([1,2,3]).length() == 3 - - assert P([]).degree() == -1 - assert P([1]).degree() == 0 - assert P([1,2]).degree() == 1 - assert P([1,2,3]).degree() == 2 - - assert (P([1]) == P([1])) is True - assert (P([1]) != P([1])) is False - assert (P([1]) == P([2])) is False - assert (P([1]) != P([2])) is True - - assert (P([1]) == 1) is True - assert (P([1]) != 1) is False - assert (P([1]) == 2) is False - assert (P([1]) != 2) is True - - assert (1 == P([1])) is True - assert (1 != P([1])) is False - assert (2 == P([1])) is False - assert (2 != P([1])) is True - - s1, s2 = S(1), S(2) - - assert (P([s1]) == s1) is True - assert (P([s1]) != s1) is False - assert (P([s1]) == s2) is False - assert (P([s1]) != s2) is True - - assert (s1 == P([s1])) is True - assert (s1 != P([s1])) is False - assert (s1 == P([s2])) is False - assert (s1 != P([s2])) is True - - assert (P([1]) == None) is False - assert (P([1]) != None) is True - assert (None == P([1])) is False - assert (None != P([1])) is True - - assert raises(lambda: P([1]) < P([1]), TypeError) # type: ignore - assert raises(lambda: P([1]) <= P([1]), TypeError) # type: ignore - assert raises(lambda: P([1]) > P([1]), TypeError) # type: ignore - assert raises(lambda: P([1]) >= P([1]), TypeError) # type: ignore - assert raises(lambda: P([1]) < None, TypeError) # type: ignore - assert raises(lambda: P([1]) <= None, TypeError) # type: ignore - assert raises(lambda: P([1]) > None, TypeError) # type: ignore - assert raises(lambda: P([1]) >= None, TypeError) # type: ignore - assert raises(lambda: None < P([1]), TypeError) # type: ignore - assert raises(lambda: None <= P([1]), TypeError) # type: ignore - assert raises(lambda: None > P([1]), TypeError) # type: ignore - assert raises(lambda: None >= P([1]), TypeError) # type: ignore - - assert P([1, 2, 3])[1] == S(2) - assert P([1, 2, 3])[-1] == S(0) - assert P([1, 2, 3])[3] == S(0) - - p = P([1, 2, 3]) - p[1] = S(4) - assert p == P([1, 4, 3]) - - def setbad(obj, i, val): - obj[i] = val - - assert raises(lambda: setbad(p, 2, None), TypeError) - assert raises(lambda: setbad(p, -1, 1), ValueError) - - for v in [], [1], [1, 2]: - p = P(v) - if type(p) == flint.fmpz_poly: - assert p.repr() == f'fmpz_poly({v!r})' - elif type(p) == flint.fmpq_poly: - assert p.repr() == f'fmpq_poly({v!r})' - elif type(p) == flint.nmod_poly: - assert p.repr() == f'nmod_poly({v!r}, {p.modulus()})' - elif type(p) == flint.fmpz_mod_poly: - assert p.repr() == f'fmpz_mod_poly({v!r}, {p.context()!r})' - elif type(p) == flint.fq_default_poly: - assert p.repr() == f'fq_default_poly({v!r}, {p.context()!r})' - else: - assert False - - assert repr(P([])) == '0' - assert repr(P([1])) == '1' - assert repr(P([1, 2])) == '2*x + 1' - assert repr(P([1, 2, 3])) == '3*x^2 + 2*x + 1' - - p = P([1, 2, 3]) - assert p(0) == p(S(0)) == S(1) == 1 - assert p(1) == p(S(1)) == S(6) == 6 - assert p(p) == P([6, 16, 36, 36, 27]) - assert raises(lambda: p(None), TypeError) # type: ignore - - assert bool(P([])) is False - assert bool(P([1])) is True - - assert P([]).is_zero() is True - assert P([1]).is_zero() is False - - assert P([]).is_one() is False - assert P([1]).is_one() is True - - assert +P([1, 2, 3]) == P([1, 2, 3]) - assert -P([1, 2, 3]) == P([-1, -2, -3]) - - assert P([1, 2, 3]) + P([4, 5, 6]) == P([5, 7, 9]) - - for T in (int, S, flint.fmpz): - assert P([1, 2, 3]) + T(1) == P([2, 2, 3]) - assert T(1) + P([1, 2, 3]) == P([2, 2, 3]) - - assert raises(lambda: P([1, 2, 3]) + None, TypeError) # type: ignore - assert raises(lambda: None + P([1, 2, 3]), TypeError) # type: ignore - - assert P([1, 2, 3]) - P([4, 5, 6]) == P([-3, -3, -3]) - - for T in (int, S, flint.fmpz): - assert P([1, 2, 3]) - T(1) == P([0, 2, 3]) - assert T(1) - P([1, 2, 3]) == P([0, -2, -3]) - - assert raises(lambda: P([1, 2, 3]) - None, TypeError) # type: ignore - assert raises(lambda: None - P([1, 2, 3]), TypeError) # type: ignore - - assert P([1, 2, 3]) * P([4, 5, 6]) == P([4, 13, 28, 27, 18]) - - for T in (int, S, flint.fmpz): - assert P([1, 2, 3]) * T(2) == P([2, 4, 6]) - assert T(2) * P([1, 2, 3]) == P([2, 4, 6]) - - assert raises(lambda: P([1, 2, 3]) * None, TypeError) # type: ignore - assert raises(lambda: None * P([1, 2, 3]), TypeError) # type: ignore - - assert P([1, 2, 1]) // P([1, 1]) == P([1, 1]) - assert P([1, 2, 1]) % P([1, 1]) == P([0]) - assert divmod(P([1, 2, 1]), P([1, 1])) == (P([1, 1]), P([0])) - - if is_field: - assert P([1, 1]) // 2 == P([S(1)/2, S(1)/2]) - assert P([1, 1]) % 2 == P([0]) - elif characteristic == 0: - assert P([1, 1]) // 2 == P([0, 0]) - assert P([1, 1]) % 2 == P([1, 1]) - elif nmod_poly_will_crash: - pass - else: - # Z/nZ for n not prime - if characteristic % 2 == 0: - assert raises(lambda: P([1, 1]) // 2, DomainError) - assert raises(lambda: P([1, 1]) % 2, DomainError) - else: - assert False - - assert 1 // P([1, 1]) == P([0]) - assert 1 % P([1, 1]) == P([1]) - assert divmod(1, P([1, 1])) == (P([0]), P([1])) - - assert raises(lambda: P([1, 2, 1]) // None, TypeError) # type: ignore - assert raises(lambda: P([1, 2, 1]) % None, TypeError) # type: ignore - assert raises(lambda: divmod(P([1, 2, 1]), None), TypeError) # type: ignore - - assert raises(lambda: None // P([1, 1]), TypeError) # type: ignore - assert raises(lambda: None % P([1, 1]), TypeError) # type: ignore - assert raises(lambda: divmod(None, P([1, 1])), TypeError) # type: ignore - - assert raises(lambda: P([1, 2, 1]) // 0, ZeroDivisionError) - assert raises(lambda: P([1, 2, 1]) % 0, ZeroDivisionError) - assert raises(lambda: divmod(P([1, 2, 1]), 0), ZeroDivisionError) - - assert raises(lambda: P([1, 2, 1]) // P([0]), ZeroDivisionError) - assert raises(lambda: P([1, 2, 1]) % P([0]), ZeroDivisionError) - assert raises(lambda: divmod(P([1, 2, 1]), P([0])), ZeroDivisionError) - - # Exact/field scalar division - if is_field: - assert P([2, 2]) / 2 == P([1, 1]) - assert P([1, 2]) / 2 == P([S(1)/2, 1]) - elif characteristic == 0: - assert P([2, 2]) / 2 == P([1, 1]) - assert raises(lambda: P([1, 2]) / 2, DomainError) - elif nmod_poly_will_crash: - pass - else: - # Z/nZ for n not prime - assert raises(lambda: P([2, 2]) / 2, DomainError) - assert raises(lambda: P([1, 2]) / 2, DomainError) - - assert raises(lambda: P([1, 2]) / 0, ZeroDivisionError) - - if not composite_characteristic: - assert P([1, 2, 1]) / P([1, 1]) == P([1, 1]) - assert raises(lambda: 1 / P([1, 1]), DomainError) - assert raises(lambda: P([1, 2, 1]) / P([1, 2]), DomainError) - - # Shifts and truncation. - assert P([1, 2, 3]).left_shift(3) == P([0, 0, 0, 1, 2, 3]) - assert P([1, 2, 3]).right_shift(1) == P([2, 3]) - assert P([1, 2, 3]).truncate(4) == P([1, 2, 3]) - assert P([1, 2, 3]).truncate(2) == P([1, 2]) - - assert P([1, 1]) ** 0 == P([1]) - assert P([1, 1]) ** 1 == P([1, 1]) - assert P([1, 1]) ** 2 == P([1, 2, 1]) - assert raises(lambda: P([1, 1]) ** -1, DomainError) - assert raises(lambda: P([1, 1]) ** None, TypeError) # type: ignore - - # Truncated operations - assert P([1, 2, 3]).mul_low(P([4, 5, 6]), 3) == P([4, 13, 28]) - assert raises(lambda: P([1, 2, 3]).mul_low(None, 3), TypeError) # type: ignore - assert raises(lambda: P([1, 2, 3]).mul_low(P([4, 5, 6]), None), TypeError) # type: ignore - - p = P([1, 2, 3]) - assert p.pow_trunc(1234, 3) == P([1, 2468, 3046746]) - assert raises(lambda: p.pow_trunc(None, 3), TypeError) # type: ignore - assert raises(lambda: p.pow_trunc(3, "A"), TypeError) # type: ignore - assert raises(lambda: p.pow_trunc(P([4, 5, 6]), 3), TypeError) # type: ignore - # Large exponents are allowed - assert p.pow_trunc(2**100, 2) == P([1, 2**101]) - assert p.pow_trunc(6**60, 3) == p.pow_trunc(2**60, 3).pow_trunc(3**60, 3) - - # XXX: Not sure what this should do in general: - p = P([1, 1]) - mod = P([1, 1]) - if isinstance(p, flint.fmpz_mod_poly) and isinstance(mod, flint.fmpz_mod_poly): - assert p * p % mod == pow(p, 2, mod) - elif isinstance(p, flint.nmod_poly) and isinstance(mod, flint.nmod_poly): - assert p * p % mod == pow(p, 2, mod) - elif isinstance(p, flint.fq_default_poly) and isinstance(mod, flint.fq_default_poly): - assert p * p % mod == pow(p, 2, mod) - else: - assert raises(lambda: pow(p, 2, mod), NotImplementedError) # type: ignore - - if not composite_characteristic: - assert P([1, 2, 1]).gcd(P([1, 1])) == P([1, 1]) - assert raises(lambda: P([1, 2, 1]).gcd(None), TypeError) # type: ignore - elif nmod_poly_will_crash: - pass - else: - # Z/nZ for n not prime - assert raises(lambda: P([1, 2, 1]).gcd(P([1, 1])), DomainError) - assert raises(lambda: P([1, 2, 1]).gcd(None), TypeError) # type: ignore - - if is_field: - p1 = P([1, 0, 1]) - p2 = P([2, 1]) - g, s, t = P([1]), P([1])/5, P([2, -1])/5 - assert p1.xgcd(p2) == (g, s, t) - assert raises(lambda: p1.xgcd(None), TypeError) # type: ignore - - if not composite_characteristic: - assert P([1, 2, 1]).factor() == (S(1), [(P([1, 1]), 2)]) - elif nmod_poly_will_crash: - pass - else: - assert raises(lambda: P([1, 2, 1]).factor(), DomainError) - - if not composite_characteristic: - assert P([1, 2, 1]).sqrt() == P([1, 1]) - assert raises(lambda: P([1, 2, 2]).sqrt(), DomainError) - elif nmod_poly_will_crash: - pass - else: - assert raises(lambda: P([1, 2, 1]).sqrt(), DomainError) - - if P == flint.fmpq_poly: - assert raises(lambda: (P([1, 2, 1])/3).sqrt(), ValueError) - assert (P([1, 2, 1])/4).sqrt() == P([1, 1])/2 - - assert P([]).deflation() == (P([]), 1) - assert P([1, 2]).deflation() == (P([1, 2]), 1) - assert P([1, 0, 2]).deflation() == (P([1, 2]), 2) - - assert P([1, 2, 1]).derivative() == P([2, 2]) - - if is_field: - p = P([1, 2, 1]) - if isinstance(p, (flint.fmpq_poly, flint.nmod_poly, flint.fmpz_mod_poly)): - assert p.integral() == P([0, 1, 1, S(1)/3]) - elif isinstance(p, flint.fq_default_poly): - assert raises(lambda: p.integral(), NotImplementedError) # type: ignore - else: - assert False - - # resultant checks. - x = P([0, 1]) - - if composite_characteristic and type(x) in [flint.fmpz_mod_poly, flint.nmod_poly]: - # Flint sometimes crashes in this case, even though the resultant - # could be computed. - divisor = characteristic.factor()[0][0] - assert raises(lambda: x.resultant(x + divisor), ValueError) - elif type(x) == flint.fq_default_poly: - # Flint does not implement resultants over GF(q) for nonprime q, so - # there's nothing for us to check. - pass - else: - assert x.resultant(x) == 0 - assert x.resultant(x**2 + x - x) == 0 - assert x.resultant(x**10 - x**5 + 1) == S(1) - assert (x - 1).resultant(x**5 + 1) == S(2) - - assert (x**5 + 1).discriminant() == S(3125) - assert (x**5 + 1).resultant(5 * x**4) == S(3125) - - for k in range(-10, 10): - assert x.resultant(x + S(k)) == S(k) - - -def test_poly_resultants(): - # Check that the resultant of two cyclotomic polynomials is right. - # See Dresden's 2012 "Resultants of Cyclotomic Polynomials" - for m in range(1, 50): - for n in range(m + 1, 50): - a = flint.fmpz_poly.cyclotomic(m) - b = flint.fmpz_poly.cyclotomic(n) - q, r = divmod(flint.fmpz(n), flint.fmpz(m)) - fs = q.factor() - if r != 0 or len(fs) > 1: - assert a.resultant(b) == 1 - else: - prime = fs[0][0] - tot = flint.fmpz(m).euler_phi() - assert a.resultant(b) == prime**tot - - -def _all_mpolys(): # -> _all_mpolys_type: - return ( - (flint.fmpz_mpoly, flint.fmpz_mpoly_ctx.get, flint.fmpz, False, flint.fmpz(0)), - (flint.fmpq_mpoly, flint.fmpq_mpoly_ctx.get, flint.fmpq, True, flint.fmpz(0)), - ( - flint.fmpz_mod_mpoly, - lambda *args, **kwargs: flint.fmpz_mod_mpoly_ctx.get(*args, **kwargs, modulus=101), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(101)), - True, - flint.fmpz(101), - ), - ( - flint.fmpz_mod_mpoly, - lambda *args, **kwargs: flint.fmpz_mod_mpoly_ctx.get(*args, **kwargs, modulus=100), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(100)), - False, - flint.fmpz(100), - ), - ( - flint.nmod_mpoly, - lambda *args, **kwargs: flint.nmod_mpoly_ctx.get(*args, **kwargs, modulus=101), - lambda x: flint.nmod(x, 101), - True, - flint.fmpz(101), - ), - ( - flint.nmod_mpoly, - lambda *args, **kwargs: flint.nmod_mpoly_ctx.get(*args, **kwargs, modulus=100), - lambda x: flint.nmod(x, 100), - False, - flint.fmpz(100), - ), - ) - - -class _GetMPolyCtx(Protocol[Tmpolyctx_p_co]): - def __call__(self, - names: Iterable[str | tuple[str, int]] | tuple[str, int], - ordering: str | flint.Ordering = "lex" - ) -> Tmpolyctx_p_co: - ... - - -_MPolyTestCase = tuple[ - type[Tmpoly_p], - _GetMPolyCtx[typ.mpoly_context_p[Tmpoly_p, Tscalar]], - Callable[[int], Tscalar], - bool, - flint.fmpz -] - - -class _Q(Protocol[Tscalar_co]): - def __call__(self, a: int, b: int | None = None, /) -> Tscalar_co: - ... - - -def _is_Q(typ: object) -> TypeIs[_Q]: - return typ is flint.fmpq - - -def _for_all_mpolys(test: Callable[[_MPolyTestCase], None]) -> None: - """Test all mpoly types with the given test function.""" - # Spell it out like this so that a type checker can understand the types - # in the generics for each call of test(). - test(( - flint.fmpz_mpoly, - flint.fmpz_mpoly_ctx.get, - flint.fmpz, - False, - flint.fmpz(0) - )) - test(( - flint.fmpq_mpoly, - flint.fmpq_mpoly_ctx.get, - flint.fmpq, - True, - flint.fmpz(0) - )) - test(( - flint.fmpz_mod_mpoly, - lambda *args, **kwargs: flint.fmpz_mod_mpoly_ctx.get(*args, **kwargs, modulus=101), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(101)), - True, - flint.fmpz(101), - )) - test(( - flint.fmpz_mod_mpoly, - lambda *args, **kwargs: flint.fmpz_mod_mpoly_ctx.get(*args, **kwargs, modulus=100), - lambda x: flint.fmpz_mod(x, flint.fmpz_mod_ctx(100)), - False, - flint.fmpz(100), - )) - test(( - flint.nmod_mpoly, - lambda *args, **kwargs: flint.nmod_mpoly_ctx.get(*args, **kwargs, modulus=101), - lambda x: flint.nmod(x, 101), - True, - flint.fmpz(101), - )) - test(( - flint.nmod_mpoly, - lambda *args, **kwargs: flint.nmod_mpoly_ctx.get(*args, **kwargs, modulus=100), - lambda x: flint.nmod(x, 100), - False, - flint.fmpz(100), - )) - - -def all_mpolys(f: Callable[[_MPolyTestCase], None]) -> Callable[[], None]: - """Decorator to run a test function for all mpoly types.""" - def wrapper(): - _for_all_mpolys(f) - wrapper.__name__ = f.__name__ - return wrapper - - -@all_mpolys -def test_mpolys_constructor(args: _MPolyTestCase[Tmpoly_p, Tscalar]) -> None: - P, get_context, S, _, _ = args - - ctx = get_context(("x", 2)) - - def mpoly(x): - return ctx.from_dict(x) - - def quick_poly(): - return mpoly({(0, 0): 1, (0, 1): 2, (1, 0): 3, (2, 2): 4}) - - assert raises(lambda : ctx.__class__("x", flint.Ordering.lex), RuntimeError) # type: ignore - assert raises(lambda: get_context(("x", 2), ordering="bad"), ValueError) # type: ignore - assert raises(lambda: get_context(("x", -1)), ValueError) - assert raises(lambda: ctx.constant("bad"), TypeError) # type: ignore - assert raises(lambda: ctx.from_dict("bad"), ValueError) # type: ignore - assert raises(lambda: ctx.from_dict({(0, 0): "bad"}), TypeError) # type: ignore - assert raises(lambda: ctx.from_dict({(0, "bad"): 1}), TypeError) # type: ignore - assert raises(lambda: ctx.from_dict({(0,): 1}), ValueError) - assert raises(lambda: ctx.gen(-1), IndexError) - assert raises(lambda: ctx.gen(10), IndexError) - - assert raises(lambda: P(val=get_context(("x",)).constant(0), ctx=ctx), IncompatibleContextError) # type: ignore - assert raises(lambda: P(val={}, ctx=None), ValueError) - assert raises(lambda: P(val={"bad": 1}, ctx=None), ValueError) # type: ignore - assert raises(lambda: P(val="1", ctx=None), ValueError) - - ctx1 = get_context(("x", 4)) - ctx2 = get_context(("x", 4), ordering="deglex") - assert ctx1.drop_gens(ctx1.names()).names() == tuple() - assert ctx1.drop_gens((ctx1.name(1), ctx1.name(2))).names() == (ctx1.name(0), ctx1.name(3)) - assert ctx1.drop_gens(tuple()).names() == ctx1.names() - assert ctx1.drop_gens((-1,)).names() == ctx1.names()[:-1] - - assert ctx.infer_generator_mapping(ctx) == {i: i for i in range(ctx.nvars())} - assert ctx1.infer_generator_mapping(ctx) == {0: 0, 1: 1} - assert ctx1.drop_gens(ctx.names()).infer_generator_mapping(ctx) == {} - - assert quick_poly().project_to_context(ctx1) == \ - ctx1.from_dict( - {(0, 0, 0, 0): 1, (0, 1, 0, 0): 2, (1, 0, 0, 0): 3, (2, 2, 0, 0): 4} - ) - new_poly = quick_poly().project_to_context(ctx1) - assert ctx1.drop_gens(new_poly.unused_gens()) == ctx - assert quick_poly().unused_gens() == () - assert (0*quick_poly()).unused_gens() == ('x0', 'x1') - assert new_poly.project_to_context(ctx) == quick_poly() - - new_poly = quick_poly().project_to_context(ctx2) - new_ctx = ctx2.drop_gens(new_poly.unused_gens()) - assert new_ctx != ctx - assert new_poly != quick_poly() - - new_ctx = new_ctx.from_context(new_ctx, ordering=ctx.ordering()) - assert new_ctx == ctx - assert new_poly.project_to_context(new_ctx) == quick_poly() - - assert ctx.append_gens(*ctx1.names()[-2:]) == ctx1 - - assert P(val={(0, 0): 1}, ctx=ctx) == ctx.from_dict({(0, 0): 1}) - assert P(ctx=ctx).context() == ctx - assert P(1, ctx=ctx).is_one() / 2 - assert ctx.gen(1) == ctx.from_dict({(0, 1): 1}) - - assert ctx.nvars() == 2 - assert ctx.ordering() == flint.Ordering.lex - - ctx1 = get_context(("x", 4)) - assert [ctx1.name(i) for i in range(4)] == ['x0', 'x1', 'x2', 'x3'] - for order in list(flint.Ordering): - ctx1 = get_context(("x", 4), ordering=order) - assert ctx1.ordering() == order - - assert ctx.constant(1) == mpoly({(0, 0): 1}) == P(1, ctx=ctx) - - assert raises(lambda: P([None]), TypeError) # type: ignore - assert raises(lambda: P(object()), TypeError) # type: ignore - assert raises(lambda: P(None), TypeError) # type: ignore - assert raises(lambda: P(None, None), TypeError) # type: ignore - assert raises(lambda: P([1,2], None), TypeError) # type: ignore - assert raises(lambda: P(1, None), ValueError) # type: ignore - - assert len(P(ctx=ctx)) == len(mpoly({(0, 0): 0})) == 0 - assert len(P(1, ctx=ctx)) == len(mpoly({(0, 0): 1})) == 1 - assert len(mpoly({(0, 0): 1, (0, 1): 1})) == 2 - assert len(mpoly({(0, 0): 1, (0, 1): 1, (1, 0): 1})) == 3 - - # degree is -1 when empty poly - assert P(ctx=ctx).degrees() == mpoly({(0, 0): 0}).degrees() == (-1, -1) - assert P(1, ctx=ctx).degrees() == mpoly({(0, 0): 1}).degrees() == (0, 0) - assert mpoly({(0, 0): 1, (0, 1): 1}).degrees() == (0, 1) - assert mpoly({(0, 0): 1, (0, 1): 1, (1, 0): 1}).degrees() == (1, 1) - assert mpoly({(0, 0): 1, (0, 1): 1, (1, 0): 1, (2, 2): 2}).degrees() == (2, 2) - - assert (P(1, ctx=ctx) == P(1, ctx=ctx)) is True - assert (P(1, ctx=ctx) != P(1, ctx=ctx)) is False - assert (P(1, ctx=ctx) == P(2, ctx=ctx)) is False - assert (P(1, ctx=ctx) != P(2, ctx=ctx)) is True - - assert (P(1, ctx=ctx) == 1) is True - assert (P(1, ctx=ctx) != 1) is False - assert (1 == P(1, ctx=ctx)) is True - assert (1 != P(1, ctx=ctx)) is False - - assert (P(1, ctx=ctx) == S(1)) is True - assert (P(1, ctx=ctx) != S(1)) is False - assert (S(1) == P(1, ctx=ctx)) is True - assert (S(1) != P(1, ctx=ctx)) is False - - assert (P(1, ctx=ctx) == P(1, ctx=ctx1)) is False - assert (P(1, ctx=ctx) != P(1, ctx=ctx1)) is True - - assert (P(1, ctx=ctx) == None) is False - assert (P(1, ctx=ctx) != None) is True - assert (None == P(1, ctx=ctx)) is False - assert (None != P(1, ctx=ctx)) is True - - assert P(ctx.from_dict({(0, 1): 3})) == ctx.from_dict({(0, 1): 3}) - assert P({(0, 1): 3}, ctx=ctx) == ctx.from_dict({(0, 1): 3}) - - if P is flint.fmpq_mpoly and isinstance(ctx, flint.fmpq_mpoly_ctx): - ctx_z = flint.fmpz_mpoly_ctx.get((("x", 2),)) - assert quick_poly() == P(ctx_z.from_dict({(0, 0): 1, (0, 1): 2, (1, 0): 3, (2, 2): 4})) - assert P(ctx_z.from_dict({(0, 0): 1}), ctx=ctx) == P({(0, 0): 1}, ctx=ctx) - - -@all_mpolys -def test_mpolys_properties(args: _MPolyTestCase[Tmpoly_p, Tscalar]) -> None: - - P, get_context, S, is_field, characteristic = args - - # Division under modulo will raise a flint exception if something is - # not invertible, crashing the program. We can't tell before what is - # invertible and what is not before hand so we always raise an - # exception, except for fmpz_mpoly, that returns an bool noting if the - # division is exact or not. - composite_characteristic = characteristic != 0 and not characteristic.is_prime() - - def mpoly(x): - return ctx.from_dict(x) - - def quick_poly(): - return mpoly({(0, 0): 1, (0, 1): 2, (1, 0): 3, (2, 2): 4}) - - ctx = get_context(("x", 2)) - ctx1 = get_context(("x", 4)) - - assert raises(lambda: P(ctx=ctx) < P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) <= P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) > P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) >= P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) < None, TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) <= None, TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) > None, TypeError) # type: ignore - assert raises(lambda: P(ctx=ctx) >= None, TypeError) # type: ignore - assert raises(lambda: None < P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: None <= P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: None > P(ctx=ctx), TypeError) # type: ignore - assert raises(lambda: None >= P(ctx=ctx), TypeError) # type: ignore - - p = quick_poly() - assert p.coefficient(2) == S(2) - assert raises(lambda: p.coefficient(-1), IndexError) - assert raises(lambda: p.coefficient(10), IndexError) - - assert raises(lambda: p[-1], TypeError) # type: ignore - assert raises(lambda: p[4], TypeError) # type: ignore - - assert p[(2, 2)] == 4 - assert p[(0, 0)] == 1 - assert raises(lambda: p[(1,)], ValueError) - assert raises(lambda: p[(1, "bad")], TypeError) # type: ignore - assert raises(lambda: p["bad"], TypeError) # type: ignore - - p = quick_poly() - p[(1, 0)] = S(10) - assert p == mpoly({(0, 0): 1, (0, 1): 2, (1, 0): 10, (2, 2): 4}) - - p = quick_poly() - p[(1, 0)] = p[(1, 0)] - assert p == quick_poly() - assert (1, 0) in p - assert (100, 100) not in p - - assert raises(lambda: p.__setitem__((4,), 1), ValueError) - - assert raises(lambda: p.__setitem__((1,), 1), ValueError) - assert raises(lambda: p.__setitem__((1, "bad"), 1), TypeError) # type: ignore - assert raises(lambda: p.__setitem__(("bad", 1), 1), TypeError) # type: ignore - - assert raises(lambda: p.__setitem__((2, 1), None), TypeError) # type: ignore - - assert P(ctx=ctx).repr() == f"{ctx.__class__.__name__}(2, '', ('x0', 'x1')).from_dict({{}})" - assert P(1, ctx=ctx).repr() == f"{ctx.__class__.__name__}(2, '', ('x0', 'x1')).from_dict({{(0, 0): 1}})" - assert str(quick_poly()) == repr(quick_poly()) == '4*x0^2*x1^2 + 3*x0 + 2*x1 + 1' - - assert p.monomial(0) == (2, 2) - assert p.monomial(3) == (0, 0) - assert raises(lambda: p.monomial(-1), IndexError) - assert raises(lambda: p.monomial(4), IndexError) - - assert p.total_degree() == 4 - assert P(ctx=ctx).total_degree() == -1 - assert P(1, ctx=ctx).total_degree() == 0 - - p = quick_poly() - assert p(0, 0) == p(0, S(0)) == p(S(0), S(0)) == S(1) == 1 - assert p(1, 1) == S(10) == 10 - - p = quick_poly() - assert p.monoms() == [(2, 2), (1, 0), (0, 1), (0, 0)] - assert p.coeffs() == [4, 3, 2, 1] - assert list(p.terms()) == list(zip([(2, 2), (1, 0), (0, 1), (0, 0)], [4, 3, 2, 1])) - - assert p.subs({"x1": S(0), 0: S(0)}) == ctx.from_dict({(0, 0): 1}) - assert p.compose(p.subs({"x1": 0}), ctx.from_dict({(0, 1): 1})) == mpoly({ - (2, 2): 36, - (1, 2): 24, - (1, 0): 9, - (0, 2): 4, - (0, 1): 2, - (0, 0): 4 - }) - assert p.compose(ctx.from_dict({(1, 0): 1}), ctx.from_dict({(0, 1): 1})) == p - - assert raises(lambda: p(None, None), TypeError) # type: ignore - assert raises(lambda: p(1), ValueError) # type: ignore - assert raises(lambda: p(0, 1, 2), ValueError) # type: ignore - - assert raises(lambda: p.subs({"x0": None}), TypeError) # type: ignore - assert raises(lambda: p.subs({"x0": None, "x1": None}), TypeError) # type: ignore - assert raises(lambda: p.subs({"a": 1}), ValueError) - assert raises(lambda: p.subs({"x0": 0, "x1": 1, "x2": 2}), ValueError) - - no_gens_ctx = get_context(tuple()) - no_gens_p = P("2", no_gens_ctx) - assert no_gens_p.compose(ctx=ctx1).context() is ctx1 - assert raises(lambda: no_gens_p.compose(), ValueError) - - assert raises(lambda: p.compose(p, P(ctx=ctx1)), IncompatibleContextError) - - assert bool(P(ctx=ctx)) is False - assert bool(P(1, ctx=ctx)) is True - - assert P(ctx=ctx).is_zero() is True - assert P(1, ctx=ctx).is_zero() is False - - assert P(ctx=ctx).is_one() is False - assert P(1, ctx=ctx).is_one() is True - - assert +quick_poly() \ - == quick_poly() - - assert -quick_poly() == mpoly({(0, 0): -1, (0, 1): -2, (1, 0): -3, (2, 2): -4}) - - assert quick_poly() \ - + mpoly({(0, 0): 5, (0, 1): 6, (1, 0): 7, (2, 2): 8}) \ - == mpoly({(0, 0): 6, (0, 1): 8, (1, 0): 10, (2, 2): 12}) - - for T in [int, S, flint.fmpz, lambda x: P(x, ctx=ctx)]: - p = quick_poly() - p += T(1) - q = quick_poly() - assert q.iadd(T(1)) is None - assert quick_poly() + T(1) \ - == p == q == mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4}) - assert T(1) + quick_poly() \ - == mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4}) - - assert raises(lambda: mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4}) + None, TypeError) # type: ignore - assert raises(lambda: None + mpoly({(0, 0): 2, (0, 1): 2, (1, 0): 3, (2, 2): 4}), TypeError) # type: ignore - assert raises(lambda: quick_poly() + P(ctx=ctx1), IncompatibleContextError) - assert raises(lambda: quick_poly().iadd(P(ctx=ctx1)), IncompatibleContextError) - assert raises(lambda: quick_poly().iadd(None), NotImplementedError) # type: ignore - - assert quick_poly() - mpoly({(0, 0): 5, (0, 1): 6, (1, 0): 7, (2, 2): 8}) \ - == mpoly({(0, 0): -4, (0, 1): -4, (1, 0): -4, (2, 2): -4}) - - for T in [int, S, flint.fmpz, lambda x: P(x, ctx=ctx)]: - p = quick_poly() - p -= T(1) - q = quick_poly() - assert q.isub(T(1)) is None - assert quick_poly() - T(1) == p == q == mpoly({(0, 1): 2, (1, 0): 3, (2, 2): 4}) - assert T(1) - quick_poly() == mpoly({(0, 1): -2, (1, 0): -3, (2, 2): -4}) - - assert raises(lambda: quick_poly() - None, TypeError) # type: ignore - assert raises(lambda: None - quick_poly(), TypeError) # type: ignore - assert raises(lambda: quick_poly() - P(ctx=ctx1), IncompatibleContextError) - assert raises(lambda: quick_poly().isub(P(ctx=ctx1)), IncompatibleContextError) - assert raises(lambda: quick_poly().isub(None), NotImplementedError) # type: ignore - - assert quick_poly() * mpoly({(1, 0): 5, (0, 1): 6}) \ - == mpoly({ - (3, 2): 20, - (2, 3): 24, - (2, 0): 15, - (1, 1): 28, - (1, 0): 5, - (0, 2): 12, - (0, 1): 6 - }) - - for T in [int, S, flint.fmpz, lambda x: P(x, ctx=ctx)]: - p = quick_poly() - p *= T(2) - q = quick_poly() - assert q.imul(T(2)) is None - assert quick_poly() * T(2) == p == q == mpoly({(0, 0): 2, (0, 1): 4, (1, 0): 6, (2, 2): 8}) - assert T(2) * quick_poly() == mpoly({(0, 0): 2, (0, 1): 4, (1, 0): 6, (2, 2): 8}) - - assert raises(lambda: quick_poly() * None, TypeError) # type: ignore - assert raises(lambda: None * quick_poly(), TypeError) # type: ignore - assert raises(lambda: quick_poly() * P(ctx=ctx1), IncompatibleContextError) - assert raises(lambda: quick_poly().imul(P(ctx=ctx1)), IncompatibleContextError) - assert raises(lambda: quick_poly().imul(None), NotImplementedError) # type: ignore - - if composite_characteristic: - assert raises(lambda: quick_poly() // mpoly({(1, 1): 1}), DomainError) - assert raises(lambda: quick_poly() % mpoly({(1, 1): 1}), DomainError) - assert raises(lambda: divmod(quick_poly(), mpoly({(1, 1): 1})), DomainError) - else: - assert quick_poly() // mpoly({(1, 1): 1}) == mpoly({(1, 1): 4}) - assert quick_poly() % mpoly({(1, 1): 1}) \ - == mpoly({(1, 0): 3, (0, 1): 2, (0, 0): 1}) - assert divmod(quick_poly(), mpoly({(1, 1): 1})) \ - == (mpoly({(1, 1): 4}), mpoly({(1, 0): 3, (0, 1): 2, (0, 0): 1})) - - assert 1 / P(1, ctx=ctx) == P(1, ctx=ctx) - assert quick_poly() / 1 == quick_poly() - assert quick_poly() // 1 == quick_poly() - assert quick_poly() % 1 == P(ctx=ctx) - assert divmod(quick_poly(), 1) == (quick_poly(), P(ctx=ctx)) - - assert S(1) / P(1, ctx=ctx) == P(1, ctx=ctx) - assert quick_poly() / S(1) == quick_poly() - assert quick_poly() // S(1) == quick_poly() - assert quick_poly() % S(1) == P(ctx=ctx) - assert divmod(quick_poly(), S(1)) == (quick_poly(), P(ctx=ctx)) - - if is_field: - assert quick_poly() / 3 == mpoly({(0, 0): S(1) / 3, (0, 1): S(2) / 3, (1, 0): S(1), (2, 2): S(4) / 3}) - else: - assert raises(lambda: quick_poly() / 3, DomainError) - - f = mpoly({(1, 1): 4, (0, 0): 1}) - g = mpoly({(0, 1): 2, (1, 0): 2}) - if not composite_characteristic: - assert 1 // quick_poly() == P(ctx=ctx) - assert 1 % quick_poly() == P(1, ctx=ctx) - assert divmod(1, quick_poly()) == (P(ctx=ctx), P(1, ctx=ctx)) - - assert S(1) // quick_poly() == P(ctx=ctx) - assert S(1) % quick_poly() == P(1, ctx=ctx) - assert divmod(S(1), quick_poly()) == (P(ctx=ctx), P(1, ctx=ctx)) - - assert f * g / mpoly({(0, 1): 1, (1, 0): 1}) \ - == mpoly({(1, 1): 8, (0, 0): 2}) - - if not is_field: - assert raises(lambda: 1 / quick_poly(), DomainError) - assert raises(lambda: quick_poly() / P(2, ctx=ctx), DomainError) - - # We prefer various other errors to the "division not supported" domain error so these are safe. - assert raises(lambda: quick_poly() / None, TypeError) # type: ignore - assert raises(lambda: quick_poly() // None, TypeError) # type: ignore - assert raises(lambda: quick_poly() % None, TypeError) # type: ignore - assert raises(lambda: divmod(quick_poly(), None), TypeError) # type: ignore - - assert raises(lambda: None / quick_poly(), TypeError) # type: ignore - assert raises(lambda: None // quick_poly(), TypeError) # type: ignore - assert raises(lambda: None % quick_poly(), TypeError) # type: ignore - assert raises(lambda: divmod(None, quick_poly()), TypeError) # type: ignore - - assert raises(lambda: quick_poly() / 0, ZeroDivisionError) - assert raises(lambda: quick_poly() // 0, ZeroDivisionError) - assert raises(lambda: quick_poly() % 0, ZeroDivisionError) - assert raises(lambda: divmod(quick_poly(), 0), ZeroDivisionError) - - assert raises(lambda: 1 / P(ctx=ctx), ZeroDivisionError) - assert raises(lambda: 1 // P(ctx=ctx), ZeroDivisionError) - assert raises(lambda: 1 % P(ctx=ctx), ZeroDivisionError) - assert raises(lambda: divmod(1, P(ctx=ctx)), ZeroDivisionError) - - assert raises(lambda: quick_poly() / P(ctx=ctx), ZeroDivisionError) - assert raises(lambda: quick_poly() // P(ctx=ctx), ZeroDivisionError) - assert raises(lambda: quick_poly() % P(ctx=ctx), ZeroDivisionError) - assert raises(lambda: divmod(quick_poly(), P(ctx=ctx)), ZeroDivisionError) - - assert raises(lambda: quick_poly() / P(1, ctx=ctx1), IncompatibleContextError) - assert raises(lambda: quick_poly() // P(1, ctx=ctx1), IncompatibleContextError) - assert raises(lambda: quick_poly() % P(1, ctx=ctx1), IncompatibleContextError) - assert raises(lambda: divmod(quick_poly(), P(1, ctx=ctx1)), IncompatibleContextError) - - assert quick_poly() ** 0 == P(1, ctx=ctx) - assert quick_poly() ** 1 == quick_poly() - assert quick_poly() ** 2 == mpoly({ - (4, 4): 16, - (3, 2): 24, - (2, 3): 16, - (2, 2): 8, - (2, 0): 9, - (1, 1): 12, - (1, 0): 6, - (0, 2): 4, - (0, 1): 4, - (0, 0): 1, - }) - assert raises(lambda: P(ctx=ctx) ** -1, ZeroDivisionError) - assert raises(lambda: P(ctx=ctx) ** None, TypeError) # type: ignore - - # # XXX: Not sure what this should do in general: - assert raises(lambda: pow(P(1, ctx=ctx), 2, 3), NotImplementedError) # type: ignore - - if composite_characteristic: - assert raises(lambda: (f * g).gcd(f), DomainError) - else: - if is_field: - assert (f * g).gcd(f) == f / 4 - else: - assert (f * g).gcd(f) == f - assert raises(lambda: quick_poly().gcd(None), TypeError) # type: ignore - assert raises(lambda: quick_poly().gcd(P(ctx=ctx1)), IncompatibleContextError) - - x0, x1 = ctx.gens() - assert (2*x0**3 + 4*x0**2 + 6*x0).term_content() == x0 if is_field else 2*x0 - assert (3*x0**2*x1 + 6*x0*x1**2 + 9*x1**3).term_content() == x1 if is_field else 3*x1 - - assert (x0**2 - 1).resultant(x0**2 - 2*x0 + 1, 'x0') == 0 - assert (x0**2 + x1**2 - 1).resultant(x0 - x1, 'x0') == 2*x1**2 - 1 - - assert (x0**3 - 6*x0**2 + 11*x0 - 6).discriminant('x0') == 4 - assert (x0**2 + 4*x0*x1 + 4*x1**2 - 1).discriminant('x0') == 4 - - f1 = 3*x0**2*x1**2 + 6*x0*x1**2 + 9*x1**2 - res, stride = f1.deflation() - assert res == 3*x0**2*x1 + 6*x0*x1 + 9*x1 - assert tuple(stride) == (1, 2) - - g1 = ((x0**2 + x1**2)**3 + (x0**2 + x1**2)**2 + 1) - res, stride = g1.deflation() - assert res == x0**3 + 3*x0**2*x1 + x0**2 + 3*x0*x1**2 + 2*x0*x1 + x1**3 + x1**2 + 1 - assert tuple(stride) == (2, 2) - - for p in [f1, g1]: - pd, n = p.deflation() - assert pd.inflate(n) == p - assert p.deflate(n).inflate(n) == p - - pd, n, m = p.deflation_monom() - assert m * pd.inflate(n) == p - - if not composite_characteristic: - n, i = p.deflation_index() - m = ctx.term(exp_vec=i) - assert (p / m).deflate(n).inflate(n) * m == p - - if isinstance(x0, flint.fmpz_mpoly) and isinstance(x1, flint.fmpz_mpoly): - assert (x0**2 * x1 + x0 * x1).primitive() == (1, x0**2*x1 + x0*x1) - assert (4 * x0 + 2 * x0 * x1).primitive() == (2, x0 * x1 + 2 * x0) - - if composite_characteristic: - # Factorisation not allowed over Z/nZ for n not prime. - # Flint would abort so we raise an exception instead: - assert raises(lambda: (f * g).factor(), DomainError) - elif characteristic == 0: - # Primitive factors over Z for fmpz_mpoly and fmpq_mpoly - assert (f * g).factor() == (S(2), [(g / 2, 1), (f, 1)]) - elif is_field: - # Monic polynomials over Z/pZ for nmod_mpoly and fmpz_mod_mpoly - assert (f * g).factor() == (S(8), [(g / 2, 1), (f / 4, 1)]) - - if composite_characteristic: - assert raises(lambda: (f * g).sqrt(), DomainError) - else: - assert (f * f).sqrt() == f - if isinstance(f, flint.fmpz_mpoly): - assert (f * f).sqrt(assume_perfect_square=True) == f - assert raises(lambda: quick_poly().sqrt(), DomainError) - - p = quick_poly() - assert p.derivative(0) == p.derivative("x0") == mpoly({(0, 0): 3, (1, 2): 8}) - assert p.derivative(1) == p.derivative("x1") == mpoly({(0, 0): 2, (2, 1): 8}) - - assert raises(lambda: p.derivative("x3"), ValueError) - assert raises(lambda: p.derivative(3), IndexError) - assert raises(lambda: p.derivative(None), TypeError) # type: ignore - - if isinstance(p, (flint.fmpz_mpoly, flint.fmpq_mpoly)): - if isinstance(p, flint.fmpq_mpoly) and _is_Q(S): - assert p.integral(0) == p.integral("x0") == \ - mpoly({(3, 2): S(4, 3), (2, 0): S(3, 2), (1, 1): S(2), (1, 0): S(1)}) - assert p.integral(1) == p.integral("x1") == \ - mpoly({(2, 3): S(4, 3), (1, 1): S(3), (0, 2): S(1), (0, 1): S(1)}) - else: - assert p.integral(0) == p.integral("x0") == \ - (6, mpoly({(3, 2): 8, (2, 0): 9, (1, 1): 12, (1, 0): 6})) - assert p.integral(1) == p.integral("x1") == \ - (3, mpoly({(2, 3): 4, (1, 1): 9, (0, 2): 3, (0, 1): 3})) - - assert raises(lambda: p.integral("x3"), ValueError) - assert raises(lambda: p.integral(3), IndexError) - assert raises(lambda: p.integral(None), TypeError) # type: ignore - - elif isinstance(p, (flint.nmod_mpoly, flint.fmpz_mod_mpoly)): - pass # No integral method - else: - assert False # New _mpoly types? - - -def _all_mpoly_vecs(): - return [(flint.fmpz_mpoly_ctx, flint.fmpz_mpoly_vec), (flint.fmpq_mpoly_ctx, flint.fmpq_mpoly_vec)] - - -def test_fmpz_mpoly_vec(): - for context, mpoly_vec in _all_mpoly_vecs(): - has_groebner_functions = mpoly_vec is flint.fmpz_mpoly_vec - - ctx = context.get((("x", 2),)) - ctx1 = context.get((("x", 4),)) - x, y = ctx.gens() - - vec = mpoly_vec(3, ctx) - - assert vec[0] == ctx.from_dict({}) - assert vec[1] == ctx.from_dict({}) - - assert vec[2] == ctx.from_dict({}) - - assert len(vec) == 3 - assert str(vec) == f"[{', '.join(str(ctx.from_dict({})) for _ in range(3))}]" - assert repr(vec) == f"{mpoly_vec.__name__}([{', '.join(str(ctx.from_dict({})) for _ in range(3))}], ctx={str(ctx)})" - - assert raises(lambda: vec[None], TypeError) # type: ignore - assert raises(lambda: vec[-1], IndexError) - - vec[1] = x * y - assert vec == mpoly_vec([ctx.from_dict({}), x * y, ctx.from_dict({})], ctx) - assert vec != mpoly_vec([x, x * y, ctx.from_dict({})], ctx) - assert vec != mpoly_vec([ctx.from_dict({})], ctx) - assert vec != mpoly_vec([ctx1.from_dict({})], ctx1) - assert tuple(vec) == tuple(mpoly_vec([ctx.from_dict({}), x * y, ctx.from_dict({})], ctx)) - assert raises(lambda: vec.__setitem__(None, 0), TypeError) # type: ignore - assert raises(lambda: vec.__setitem__(-1, 0), IndexError) # type: ignore - assert raises(lambda: vec.__setitem__(0, 0), TypeError) # type: ignore - assert raises(lambda: vec.__setitem__(0, ctx1.from_dict({})), IncompatibleContextError) - - if has_groebner_functions: - ctx = context.get(("x", "y", "z")) - - # Examples here cannibalised from - # https://en.wikipedia.org/wiki/Gr%C3%B6bner_basis#Example_and_counterexample - x, y, z = ctx.gens() - f = x**2 - y - f2 = 3 * x**2 - y - g = x**3 - x - g2 = x**3 * y - x - k = x * y - x - k2 = 3 * x * y - 3 * x - h = y**2 - y - - vec = mpoly_vec([f, k, h], ctx) - assert vec.is_groebner() - assert vec.is_groebner(mpoly_vec([f, g], ctx)) - assert not vec.is_groebner(mpoly_vec([f, x**3], ctx)) - - assert mpoly_vec([f2, k, h], ctx).is_autoreduced() - assert not mpoly_vec([f2, k2, h], ctx).is_autoreduced() - - vec = mpoly_vec([f2, k2, h], ctx) - vec2 = vec.autoreduction() - assert not vec.is_autoreduced() - assert vec2.is_autoreduced() - assert vec2 == mpoly_vec([3 * x**2 - y, x * y - x, y**2 - y], ctx) - - vec = mpoly_vec([f, g2], ctx) - assert not vec.is_groebner() - assert vec.buchberger_naive() == mpoly_vec([x**2 - y, x**3 * y - x, x * y**2 - x, y**3 - y], ctx) - assert vec.buchberger_naive(limits=(2, 2, 512)) == (mpoly_vec([x**2 - y, x**3 * y - x], ctx), False) - - unreduced_basis = mpoly_vec([x**2 - 2, y**2 - 3, z - x - y], ctx).buchberger_naive() - assert list(unreduced_basis) == [ - x**2 - 2, - y**2 - 3, - x + y - z, - 2*y*z - z**2 - 1, - 2*y + z**3 - 11*z, - z**4 - 10*z**2 + 1 - ] - - assert list(unreduced_basis.autoreduction()) == [ - z**4 - 10 * z**2 + 1, - 2*y + z**3 - 11 * z, - 2 * x - z**3 + 9 * z - ] - - -def _all_polys_mpolys(): - - for P, S, is_field, characteristic in _all_polys(): - x = P([0, 1]) - y = None - assert isinstance(x, ( - flint.fmpz_poly, - flint.fmpq_poly, - flint.nmod_poly, - flint.fmpz_mod_poly, - flint.fq_default_poly, - )) - yield P, S, [x, y], is_field, characteristic - - for P, get, S, is_field, characteristic in _all_mpolys(): - ctx = get(("x", "y")) - x, y = ctx.gens() - assert isinstance(x, ( - flint.fmpz_mpoly, - flint.fmpq_mpoly, - flint.nmod_mpoly, - flint.fmpz_mod_mpoly, - )) - yield P, S, [x, y], is_field, characteristic - - -def test_properties_poly_mpoly(): - """Test is_zero, is_one etc for all polynomials.""" - for _, _, [x, _], _, _ in _all_polys_mpolys(): - - zero = 0*x - one = zero + 1 - two = one + 1 - - assert zero.is_zero() is True - assert one.is_zero() is False - assert two.is_zero() is False - assert x.is_zero() is False - - assert zero.is_one() is False - assert one.is_one() is True - assert two.is_one() is False - assert x.is_one() is False - - assert zero.is_constant() is True - assert one.is_constant() is True - assert two.is_constant() is True - assert x.is_constant() is False - - # is_gen? - - -def test_factor_poly_mpoly(): - """Test that factor() is consistent across different poly/mpoly types.""" - - def check(p, coeff, factors): - # Check all the types - lc = p.leading_coefficient() - assert type(coeff) is type(lc) - assert isinstance(factors, list) - assert all(isinstance(f, tuple) for f in factors) - for fac, m in factors: - assert type(fac) is type(p) - assert type(m) is int - - # Check the actual factorisation! - res = coeff - for fac, m in factors: - res *= fac ** m - assert res == p - - def sort(factors): - def sort_key(p): - fac, m = p - return (m, sorted(str(i) for i in fac.coeffs())) - return sorted(factors, key=sort_key) - - def factor(p): - coeff, factors = p.factor() - check(p, coeff, factors) - return coeff, sort(factors) - - def factor_sqf(p): - coeff, factors = p.factor_squarefree() - check(p, coeff, factors) - return coeff, sort(factors) - - for P, S, [x, y], is_field, characteristic in _all_polys_mpolys(): - - if characteristic != 0 and not characteristic.is_prime(): - # nmod_poly crashes for many operations with non-prime modulus - # https://github.com/flintlib/python-flint/issues/124 - # so we can't even test it... - nmod_poly_will_crash = type(x) is flint.nmod_poly - if nmod_poly_will_crash: - continue - - try: - assert S(4).sqrt() ** 2 == S(4) - except DomainError: - pass - assert raises(lambda: (x**2).sqrt(), DomainError) - assert raises(lambda: x.gcd(x), DomainError) - assert raises(lambda: x.gcd(None), TypeError) # type: ignore - assert raises(lambda: x.factor(), DomainError) - assert raises(lambda: x.factor_squarefree(), DomainError) - - # All tests below can be expected to raise DomainError - # Not sure if that is guaranteed in all cases though... - continue - - assert S(0).sqrt() == S(0) - assert S(1).sqrt() == S(1) - assert S(4).sqrt()**2 == S(4) - - for i in range(-100, 100): - try: - assert S(i).sqrt() ** 2 == S(i) - except DomainError: - pass - - if characteristic == 0: - assert raises(lambda: S(-1).sqrt(), DomainError) - - assert (0*x).sqrt() == 0*x - assert (1*x/x).sqrt() == 0*x + 1 - assert (4*x/x).sqrt()**2 == 0*x + 4 - - for i in range(-100, 100): - try: - assert (i*x).sqrt() ** 2 == i*x - except DomainError: - pass - - assert (x**2).sqrt() == x - assert (S(4)*x**2).sqrt()**2 == S(4)*x**2 - assert raises(lambda: (x**2 + 1).sqrt(), DomainError) - - assert factor(0*x) == (S(0), []) - assert factor(0*x + 1) == (S(1), []) - assert factor(0*x + 3) == (S(3), []) - assert factor(x) == (S(1), [(x, 1)]) - assert factor(-x) == (S(-1), [(x, 1)]) - assert factor(x**2) == (S(1), [(x, 2)]) - assert factor(2*(x+1)) == (S(2), [(x+1, 1)]) - - assert factor_sqf(0*x) == (S(0), []) - assert factor_sqf(0*x + 1) == (S(1), []) - assert factor_sqf(0*x + 3) == (S(3), []) - assert factor_sqf(-x) == (S(-1), [(x, 1)]) - assert factor_sqf(x**2) == (S(1), [(x, 2)]) - assert factor_sqf(2*(x+1)) == (S(2), [(x+1, 1)]) - - assert (0*x).gcd(0*x) == 0*x - assert (0*x).gcd(0*x + 1) == S(1) - - if not is_field: - assert (0*x).gcd(0*x + 3) == S(3) - else: - assert (0*x).gcd(0*x + 3) == S(1) - - assert (2*x).gcd(x) == x - assert (2*x).gcd(x**2) == x - assert (2*x).gcd(x**2 + 1) == S(1) - - if not is_field: - # primitive gcd over Z - assert (2*x).gcd(4*x**2) == 2*x - else: - # monic gcd over Q, Z/pZ and GF(p^d) - assert (2*x).gcd(4*x**2) == x - - if is_field and y is None: - # xgcd is defined and consistent for all univariate polynomials - # over a field (Q, Z/pZ, GF(p^d)). - assert (2*x).xgcd(4*x) == (x, P(0), P(1)/4) - assert (2*x).xgcd(4*x**2+1) == (P(1), -2*x, P(1)) - - # mpoly types have a slightly different squarefree factorisation - # because they handle trivial factors differently. It looks like a - # monomial gcd is extracted but not recombined so the square-free - # factors might not have unique multiplicities. - # - # Maybe it is worth making them consistent by absorbing the power - # of x into a factor of equal multiplicity. - assert factor(x*(x+1)) == (S(1), [(x, 1), (x+1, 1)]) - if y is None: - # *_poly types - assert factor_sqf(x*(x+1)) == (S(1), [(x**2+x, 1)]) - else: - # *_mpoly types - assert factor_sqf(x*(x+1)) == (S(1), [(x, 1), (x+1, 1)]) - - # This is the same for all types because the extracted monomial has - # a unique multiplicity. - assert factor_sqf(x**2*(x+1)) == (S(1), [(x+1, 1), (x, 2)]) - - # This is the same for all types because there is no trivial monomial - # factor to extract. - assert factor((x-1)*(x+1)) == (S(1), sort([(x-1, 1), (x+1, 1)])) - assert factor_sqf((x-1)*(x+1)) == (S(1), [(x**2-1, 1)]) - - # Some finite fields have sqrt(-1) so we can factor x**2 + 1 - try: - i = S(-1).sqrt() - except DomainError: - i = None - - p = 3*(x-1)**2*(x+1)**2*(x**2 + 1)**3 - assert factor_sqf(p) == (S(3), [(x**2 - 1, 2), (x**2 + 1, 3)]) - - if i is not None: - assert factor(p) == (S(3), sort([(x+1, 2), (x-1, 2), (x+i, 3), (x-i, 3)])) - else: - assert factor(p) == (S(3), sort([(x-1, 2), (x+1, 2), (x**2+1, 3)])) - - if characteristic == 0: - # primitive factors over Z for Z and Q. - assert factor(2*x+1) == (S(1), [(2*x+1, 1)]) - else: - # monic factors over Z/pZ and GF(p^d) - assert factor(2*x+1) == (S(2), [(x+S(1)/2, 1)]) - - if is_field: - if characteristic == 0: - assert factor((2*x+1)/7) == (S(1)/7, [(2*x+1, 1)]) - else: - assert factor((2*x+1)/7) == (S(2)/7, [(x+S(1)/2, 1)]) - - if y is not None: - - # *_mpoly types - - assert factor(x*y+1) == (S(1), [(x*y+1, 1)]) - assert factor(x*y) == (S(1), [(y, 1), (x, 1)]) - - assert factor_sqf((x*y+1)**2*(x*y-1)) == (S(1), [(x*y-1, 1), (x*y+1, 2)]) - - p = 2*x + y - if characteristic == 0: - assert factor(p) == factor_sqf(p) == (S(1), [(p, 1)]) - else: - assert factor(p) == factor_sqf(p) == (S(2), [(p/2, 1)]) - - if is_field: - p = (2*x + y)/7 - if characteristic == 0: - assert factor(p) == factor_sqf(p) == (S(1)/7, [(7*p, 1)]) - else: - assert factor(p) == factor_sqf(p) == (S(2)/7, [(7*p/2, 1)]) - - if not is_field: - # primitive gcd over Z - assert (2*(x+y)).gcd(4*(x+y)**2) == 2*(x+y) - else: - # monic gcd over Q, Z/pZ and GF(p^d) - assert (2*(x+y)).gcd(4*(x+y)**2) == x + y - - -def test_division_poly_mpoly(): - """Test that division is consistent across different poly/mpoly types.""" - - Z = flint.fmpz - - for _, S, [x, _], is_field, characteristic in _all_polys_mpolys(): - - if characteristic != 0 and not characteristic.is_prime(): - # nmod_poly crashes for many operations with non-prime modulus - # https://github.com/flintlib/python-flint/issues/124 - # so we can't even test it... - nmod_poly_will_crash = type(x) is flint.nmod_poly - if nmod_poly_will_crash: - continue - - one = x**0 # 1 as a polynomial - two = one + one - - if is_field or characteristic == 0: - assert x / x == x**0 == 1 == one - assert x / 1 == x / S(1) == x / one == x**1 == x - assert 1 / one == one**-1 == one**Z(-1) == 1, type(one) - assert -1 / one == 1 / -one == (-one)**-1 == (-one)**Z(-1) == -one == -1 - assert (-one) ** -2 == (-one)**Z(-2) == one - assert raises(lambda: 1 / x, DomainError) - assert raises(lambda: x ** -1, DomainError) - - if is_field: - half = S(1)/2 * one # 1/2 as a polynomial - assert half == S(1)/2 - assert x / half == 2*x - assert 1 / half == S(1) / half == one / half == one / (S(1)/2) == 2 - assert half ** -1 == half ** Z(-1) == 2 - assert two ** -1 == two ** Z(-1) == half - elif characteristic == 0: - assert raises(lambda: x / 2, DomainError) - assert raises(lambda: x / two, DomainError) - assert raises(lambda: two ** -1, DomainError) - assert raises(lambda: two ** Z(-1), DomainError) - else: - # Non-prime modulus... - # nmod can crash and fmpz_mod_poly won't crash but has awkward - # behaviour under division. - pass - - -def _all_matrices(): - """Return a list of matrix types and scalar types.""" - R163 = flint.fmpz_mod_ctx(163) - R127 = flint.fmpz_mod_ctx(2**127 - 1) - R255 = flint.fmpz_mod_ctx(2**255 - 19) - return [ - # (matrix_type, scalar_type, is_field) - (flint.fmpz_mat, flint.fmpz, False), - (flint.fmpq_mat, flint.fmpq, True), - (lambda *a: flint.nmod_mat(*a, 17), lambda x: flint.nmod(x, 17), True), - (lambda *a: flint.fmpz_mod_mat(*a, R163), lambda x: flint.fmpz_mod(x, R163), True), - (lambda *a: flint.fmpz_mod_mat(*a, R127), lambda x: flint.fmpz_mod(x, R127), True), - (lambda *a: flint.fmpz_mod_mat(*a, R255), lambda x: flint.fmpz_mod(x, R255), True), - ] - - -def _coercible_matrix_types(mat_type): - """Return a list of matrix types that can be coerced to `mat_type`.""" - M = mat_type([[1, 2], [3, 4]]) - - if type(M) is flint.fmpz_mat: - return [ - flint.fmpz_mat - ] - elif type(M) is flint.fmpq_mat: - return [ - flint.fmpz_mat, - flint.fmpq_mat - ] - elif type(M) is flint.nmod_mat: - m = M.modulus() - return [ - flint.fmpz_mat, - lambda *a: flint.nmod_mat(*a, m) - ] - elif type(M) is flint.fmpz_mod_mat: - m = M.modulus() - c = flint.fmpz_mod_ctx(m) - mat_types = [ - flint.fmpz_mat, - lambda *a: flint.fmpz_mod_mat(*a, c) - ] - if m < 2**64 - 1: - mat_types.append(lambda *a: flint.nmod_mat(*a, m)) - return mat_types - else: - assert False - - -def _compatible_matrix_types(mat_type): - """Return a list of matrix types that can be added to `mat_type`.""" - M = mat_type([[1, 2], [3, 4]]) - - if type(M) is flint.fmpz_mat: - return [ - flint.fmpz_mat - ] - elif type(M) is flint.fmpq_mat: - return [ - # flint.fmpz_mat, - flint.fmpq_mat - ] - elif type(M) is flint.nmod_mat: - m = M.modulus() - return [ - flint.fmpz_mat, - lambda *a: flint.nmod_mat(*a, m) - ] - elif type(M) is flint.fmpz_mod_mat: - m = M.modulus() - c = flint.fmpz_mod_ctx(m) - mat_types = [ - flint.fmpz_mat, - lambda *a: flint.fmpz_mod_mat(*a, c) - ] - if m < 2**64 - 1: - mat_types.append(lambda *a: flint.nmod_mat(*a, m)) - return mat_types - else: - assert False - - -def _incompatible_matrix_types(mat_type): - M = mat_type([[1, 2], [3, 4]]) - - if type(M) is flint.fmpz_mat: - return [] - elif type(M) is flint.fmpq_mat: - return [ - lambda *a: flint.nmod_mat(*a, 17), - lambda *a: flint.fmpz_mod_mat(*a, flint.fmpz_mod_ctx(163)), - ] - elif type(M) is flint.nmod_mat: - m = M.modulus() - m2 = m - 1 - return [ - flint.fmpq_mat, - lambda *a: flint.nmod_mat(*a, m2), - ] - elif type(M) is flint.fmpz_mod_mat: - m = M.modulus() - m2 = m - 1 - mat_types = [ - flint.fmpq_mat, - lambda *a: flint.fmpz_mod_mat(*a, flint.fmpz_mod_ctx(m2)), - ] - if m < 2**64 - 1: - mat_types.append(lambda *a: flint.nmod_mat(*a, m2)) - return mat_types - else: - assert False - - -def _poly_type_from_matrix_type(mat_type): - M = mat_type([[1, 2], [3, 4]]) - - if type(M) is flint.fmpz_mat: - return flint.fmpz_poly - elif type(M) is flint.fmpq_mat: - return flint.fmpq_poly - elif type(M) is flint.nmod_mat: - m = M.modulus() - return lambda *a: flint.nmod_poly(*a, m) - elif type(M) is flint.fmpz_mod_mat: - m = M.modulus() - ctx = flint.fmpz_mod_ctx(m) - pctx = flint.fmpz_mod_poly_ctx(ctx) - return lambda *a: flint.fmpz_mod_poly(*a, pctx) - else: - assert False - - -def test_matrices_eq(): - for M, _, _ in _all_matrices(): - A1 = M([[1, 2], [3, 4]]) - A2 = M([[1, 2], [3, 4]]) - B = M([[5, 6], [7, 8]]) - assert (A1 == A2) is True - assert (A1 != A2) is False - assert (A1 == B) is False - assert (A1 != B) is True - assert (A1 == None) is False - assert (A1 != None) is True - assert (None == A1) is False - assert (None != A1) is True - assert raises(lambda: A1 < A2, TypeError) - assert raises(lambda: A1 <= A2, TypeError) - assert raises(lambda: A1 > A2, TypeError) - assert raises(lambda: A1 >= A2, TypeError) - - for M2 in _incompatible_matrix_types(M): - A1 = M([[1, 2], [3, 4]]) - A2 = M2([[1, 2], [3, 4]]) - assert (A1 == A2) is False - assert (A1 != A2) is True - - -def test_matrices_constructor(): - for M, S, _ in _all_matrices(): - assert raises(lambda: M(), TypeError) - - # Empty matrices - assert M([]).nrows() == 0 - assert M([]).ncols() == 0 - assert M([]) != M([[]]) - assert M([[]]).nrows() == 1 - assert M([[]]).ncols() == 0 - assert M([]) == M(0, 0, []) == M(0, 0) - assert M([[]]) == M(1, 0, []) == M(1, 0) - assert M([[], []]) == M(2, 0, []) == M(2, 0) - assert M(0, 2, []) == M(0, 2) != M(2, 0) - - # Basic construction - M1234 = M([[1, 2], [3, 4]]) - assert M1234.nrows() == 2 - assert M1234.ncols() == 2 - assert M1234 == M([[1, 2], [3, 4]]) - assert M1234 != M([[1, 2], [3, 5]]) - assert M1234 == M(2, 2, [1, 2, 3, 4]) - assert M1234.entries() == [S(1), S(2), S(3), S(4)] - assert M1234.table() == [[S(1), S(2)], [S(3), S(4)]] - assert M1234[0, 0] == S(1) - assert M1234[0, 1] == S(2) - assert M1234[1, 0] == S(3) - assert M1234[1, 1] == S(4) - assert type(M1234[0, 0]) is type(S(1)) - assert M1234 == M([[S(1), S(2)], [S(3), S(4)]]) - assert M1234 == M(2, 2, [S(1), S(2), S(3), S(4)]) - - # Non-square matrices - M6 = M([[1, 2, 3], [4, 5, 6]]) - assert M6.nrows() == 2 - assert M6.ncols() == 3 - assert M6 == M(2, 3, [1, 2, 3, 4, 5, 6]) - assert M6.entries() == [S(1), S(2), S(3), S(4), S(5), S(6)] - assert M6 != M1234 - - # Bad list inputs - assert raises(lambda: M(None), TypeError) - assert raises(lambda: M([None]), TypeError) - assert raises(lambda: M(2, 3, [1, 2, 3, 4, 5]), ValueError) - assert raises(lambda: M([[1, 2], [3, 4], [5, 6, 7]]), ValueError) - assert raises(lambda: M([[1, 2], [3, 4], [5, 6, 7, 8]]), ValueError) - assert raises(lambda: M([[1, 2], [3, None]]), TypeError) - - # Construct from a coercible matrix - M1234 = M([[1, 2], [3, 4]]) - for M2 in _coercible_matrix_types(M): - if type(M2([[1]])) is flint.nmod_mat: - continue - M1234_2 = M(M2([[1, 2], [3, 4]])) - assert M1234_2 == M1234 - assert type(M1234_2) is type(M1234) - - -def _matrix_repr(M): - item = M[0, 0] - if type(item) is flint.fmpz: - return f"fmpz_mat({M.nrows()}, {M.ncols()}, {M.entries()!r})" - elif type(item) is flint.fmpq: - return f"fmpq_mat({M.nrows()}, {M.ncols()}, {M.entries()!r})" - elif type(item) is flint.nmod: - return f"nmod_mat({M.nrows()}, {M.ncols()}, {M.entries()!r}, {M.modulus()})" - elif type(item) is flint.fmpz_mod: - return f"fmpz_mod_mat({M.nrows()}, {M.ncols()}, {M.entries()!r}, {M.modulus()})" - else: - assert False - - -def test_matrices_strrepr(): - for M, _, _ in _all_matrices(): - A = M([[1, 2], [3, 4]]) - A_str = "[1, 2]\n[3, 4]" - A_repr = _matrix_repr(A) - - assert A.str() == A_str, type(A).__name__ - assert A.repr() == A_repr, type(A).__name__ - - # str always returns a pretty result - assert str(A) == A_str, type(A).__name__ - - # repr depends on ctx.pretty - pretty = ctx.pretty - try: - ctx.pretty = True - assert repr(A) == A_str, type(A).__name__ - ctx.pretty = False - assert repr(A) == A_repr, type(A).__name__ - finally: - ctx.pretty = pretty - - -def test_matrices_getitem(): - for M, S, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - assert M1234[0, 0] == S(1) - assert M1234[0, 1] == S(2) - assert M1234[1, 0] == S(3) - assert M1234[1, 1] == S(4) - assert raises(lambda: M1234[0, 2], IndexError) - assert raises(lambda: M1234[2, 0], IndexError) - assert raises(lambda: M1234[2, 2], IndexError) - # XXX: Should negative indices be allowed? - assert raises(lambda: M1234[-1, 0], IndexError) - assert raises(lambda: M1234[0, -1], IndexError) - assert raises(lambda: M1234[-1, -1], IndexError) - - -def test_matrices_setitem(): - for M, S, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - - assert M1234[0, 0] == S(1) - M1234[0, 0] = S(5) - assert M1234[0, 0] == S(5) - assert M1234.table() == [[S(5), S(2)], [S(3), S(4)]] - - def setbad(obj, key, val): - obj[key] = val - - assert raises(lambda: setbad(M1234, (0,0), None), TypeError) - assert raises(lambda: setbad(M1234, (0,None), 1), TypeError) - assert raises(lambda: setbad(M1234, (None,0), 1), TypeError) - assert raises(lambda: setbad(M1234, None, 1), TypeError) - - assert raises(lambda: setbad(M1234, (0,2), 1), IndexError) - assert raises(lambda: setbad(M1234, (2,0), 1), IndexError) - assert raises(lambda: setbad(M1234, (2,2), 1), IndexError) - # XXX: Should negative indices be allowed? - assert raises(lambda: setbad(M1234, (-1,0), 1), IndexError) - assert raises(lambda: setbad(M1234, (0,-1), 1), IndexError) - assert raises(lambda: setbad(M1234, (-1,-1), 1), IndexError) - - -def test_matrices_bool(): - for M, _, _ in _all_matrices(): - assert bool(M([])) is False - assert bool(M([[0]])) is False - assert bool(M([[1]])) is True - assert bool(M([[0, 0], [0, 0]])) is False - assert bool(M([[1, 0], [0, 0]])) is True - assert bool(M([[0, 0], [0, 1]])) is True - assert bool(M([[1, 0], [0, 1]])) is True - - -def test_matrices_pos_neg(): - for M, _, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - assert +M1234 == M1234 - assert -M1234 == M([[-1, -2], [-3, -4]]) - - -def test_matrices_add(): - for M, _, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - M5678 = M([[5, 6], [7, 8]]) - assert M1234 + M5678 == M([[6, 8], [10, 12]]) - assert raises(lambda: M1234 + 1, TypeError) - assert raises(lambda: 1 + M1234, TypeError) - assert raises(lambda: M1234 + None, TypeError) - assert raises(lambda: None + M1234, TypeError) - assert raises(lambda: M1234 + M([[1, 2, 3], [4, 5, 6]]), ValueError) - for M2 in _compatible_matrix_types(M): - assert M1234 + M2([[1, 2], [3, 4]]) == M([[2, 4], [6, 8]]) - assert M2([[1, 2], [3, 4]]) + M1234 == M([[2, 4], [6, 8]]) - assert raises(lambda: M1234 + M2([[1, 2, 3], [4, 5, 6]]), ValueError) - assert raises(lambda: M2([[1, 2, 3], [4, 5, 6]]) + M1234, ValueError) - for M2 in _incompatible_matrix_types(M): - assert raises(lambda: M1234 + M2([[1, 2], [3, 4]]), (TypeError, ValueError)) - assert raises(lambda: M2([[1, 2], [3, 4]]) + M1234, (TypeError, ValueError)) - - -def test_matrices_sub(): - for M, _, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - M5678 = M([[5, 6], [7, 8]]) - assert M1234 - M5678 == M([[-4, -4], [-4, -4]]) - assert raises(lambda: M1234 - 1, TypeError) - assert raises(lambda: 1 - M1234, TypeError) - assert raises(lambda: M1234 - None, TypeError) - assert raises(lambda: None - M1234, TypeError) - assert raises(lambda: M1234 - M([[1, 2, 3], [4, 5, 6]]), ValueError) - for M2 in _compatible_matrix_types(M): - assert M1234 - M2([[1, 2], [3, 4]]) == M([[0, 0], [0, 0]]) - assert M2([[1, 2], [3, 4]]) - M1234 == M([[0, 0], [0, 0]]) - assert raises(lambda: M1234 - M2([[1, 2, 3], [4, 5, 6]]), ValueError) - assert raises(lambda: M2([[1, 2, 3], [4, 5, 6]]) - M1234, ValueError) - for M2 in _incompatible_matrix_types(M): - assert raises(lambda: M1234 - M2([[1, 2], [3, 4]]), (TypeError, ValueError)) - assert raises(lambda: M2([[1, 2], [3, 4]]) - M1234, (TypeError, ValueError)) - - -def test_matrices_mul(): - for M, S, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - M5678 = M([[5, 6], [7, 8]]) - assert M1234 * M5678 == M([[19, 22], [43, 50]]) - M21 = M([[2], [1]]) - assert M1234 * M21 == M([[4], [10]]) - - assert 2 * M1234 == M([[2, 4], [6, 8]]) - assert M1234 * 2 == M([[2, 4], [6, 8]]) - assert S(2) * M1234 == M([[2, 4], [6, 8]]) - assert M1234 * S(2) == M([[2, 4], [6, 8]]) - assert raises(lambda: M1234 * None, TypeError) - assert raises(lambda: None * M1234, TypeError) - assert raises(lambda: M1234 * M([[1, 2], [3, 4], [5, 6]]), ValueError) - assert raises(lambda: M([[1, 2, 3], [4, 5, 6]]) * M1234, ValueError) - - for M2 in _compatible_matrix_types(M): - assert M1234 * M2([[1, 2], [3, 4]]) == M([[7, 10], [15, 22]]) - assert M2([[1, 2], [3, 4]]) * M1234 == M([[7, 10], [15, 22]]) - - for M2 in _incompatible_matrix_types(M): - assert raises(lambda: M1234 * M2([[1, 2], [3, 4]]), (TypeError, ValueError)) - assert raises(lambda: M2([[1, 2], [3, 4]]) * M1234, (TypeError, ValueError)) - - -def test_matrices_pow(): - for M, _, is_field in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - assert M1234**0 == M([[1, 0], [0, 1]]) - assert M1234**1 == M1234 - assert M1234**2 == M([[7, 10], [15, 22]]) - assert M1234**3 == M([[37, 54], [81, 118]]) - if is_field: - assert M1234**-1 == M([[-4, 2], [3, -1]]) / 2 - assert M1234**-2 == M([[22, -10], [-15, 7]]) / 4 - assert M1234**-3 == M([[-118, 54], [81, -37]]) / 8 - Ms = M([[1, 2], [3, 6]]) - assert raises(lambda: Ms**-1, ZeroDivisionError) - Mr = M([[1, 2, 3], [4, 5, 6]]) - assert raises(lambda: Mr**0, ValueError) - assert raises(lambda: Mr**1, ValueError) - assert raises(lambda: Mr**2, ValueError) - assert raises(lambda: M1234**None, TypeError) - assert raises(lambda: None**M1234, TypeError) - - -def test_matrices_div(): - for M, S, is_field in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - if is_field: - assert M1234 / 2 == M([[S(1)/2, S(1)], [S(3)/2, 2]]) - assert M1234 / S(2) == M([[S(1)/2, S(1)], [S(3)/2, 2]]) - assert raises(lambda: M1234 / 0, ZeroDivisionError) - assert raises(lambda: M1234 / S(0), ZeroDivisionError) - raises(lambda: M1234 / None, TypeError) - raises(lambda: None / M1234, TypeError) - - -def test_matrices_properties(): - for M, _, _ in _all_matrices(): - # XXX: Add these properties to all matrix types - if M is not flint.fmpz_mat: - continue - - assert M([[1, 2], [3, 4]]).is_square() is True - assert M([[1, 2]]).is_square() is False - assert M(0, 2, []).is_square() is False - assert M(2, 0, []).is_square() is False - - assert M([[1, 2], [3, 4]]).is_empty() is False - assert M(0, 2, []).is_empty() is True - assert M(2, 0, []).is_empty() is True - - assert M([[1, 2], [3, 4]]).is_zero() is False - assert M([[0, 0], [0, 0]]).is_zero() is True - - assert M([[1, 0], [0, 1]]).is_one() is True - assert M([[1, 2], [3, 4]]).is_one() is False - assert M([[1, 0], [0, 1], [0, 0]]).is_one() is True # ?? - assert M(0, 0, []).is_one() is True - - assert M([[-1, 0], [0, -1]]).is_neg_one() is True - assert M([[-1, 0], [0, 1]]).is_neg_one() is False - assert M([[-1, -1], [-1, -1]]).is_neg_one() is False - assert M([[-1, 0], [0, -1], [0, 0]]).is_neg_one() is False # ?? - assert M(0, 0, []).is_neg_one() is True - - assert M([[2, 0], [0, 2]]).is_scalar() is True - assert M([[2, 0], [0, 3]]).is_scalar() is False - assert M([[1, 0], [0, 1], [0, 0]]).is_scalar() is False - - assert M([[1, 0], [0, 2]]).is_diagonal() is True - assert M([[1, 0], [1, 2]]).is_diagonal() is False - assert M([[1, 0], [0, 1], [0, 0]]).is_diagonal() is True - - assert M([[1, 1, 1], [0, 2, 2]]).is_upper_triangular() is True - assert M([[1, 1, 1], [1, 2, 2]]).is_upper_triangular() is False - - assert M([[1, 0, 0], [1, 2, 0]]).is_lower_triangular() is True - assert M([[1, 1, 0], [1, 2, 0]]).is_lower_triangular() is False - - -def test_matrices_inv(): - for M, S, is_field in _all_matrices(): - if is_field: - M1234 = M([[1, 2], [3, 4]]) - assert M1234.inv() == M([[-2, 1], [S(3)/2, -S(1)/2]]) - M1236 = M([[1, 2], [3, 6]]) - assert raises(lambda: M1236.inv(), ZeroDivisionError) - Mr = M([[1, 2, 3], [4, 5, 6]]) - assert raises(lambda: Mr.inv(), ValueError) - # XXX: Test non-field matrices. unimodular? - - -def test_matrices_det(): - for M, S, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - assert M1234.det() == S(-2) - M9 = M([[1, 2, 3], [4, 5, 6], [7, 8, 10]]) - assert M9.det() == S(-3) - Mr = M([[1, 2, 3], [4, 5, 6]]) - assert raises(lambda: Mr.det(), ValueError) - - -def test_matrices_charpoly(): - for M, _, _ in _all_matrices(): - P = _poly_type_from_matrix_type(M) - M1234 = M([[1, 2], [3, 4]]) - assert M1234.charpoly() == P([-2, -5, 1]) - M9 = M([[1, 2, 3], [4, 5, 6], [7, 8, 10]]) - assert M9.charpoly() == P([3, -12, -16, 1]) - Mr = M([[1, 2, 3], [4, 5, 6]]) - assert raises(lambda: Mr.charpoly(), ValueError) - - -def test_matrices_minpoly(): - for M, _, _ in _all_matrices(): - P = _poly_type_from_matrix_type(M) - M1234 = M([[1, 2], [3, 4]]) - assert M1234.minpoly() == P([-2, -5, 1]) - M9 = M([[2, 1, 0], [0, 2, 0], [0, 0, 2]]) - assert M9.minpoly() == P([4, -4, 1]) - Mr = M([[1, 2, 3], [4, 5, 6]]) - assert raises(lambda: Mr.minpoly(), ValueError) - - -def test_matrices_rank(): - for M, _, _ in _all_matrices(): - M1234 = M([[1, 2], [3, 4]]) - assert M1234.rank() == 2 - Mr = M([[1, 2, 3], [4, 5, 6]]) - assert Mr.rank() == 2 - Ms = M([[1, 2], [2, 4]]) - assert Ms.rank() == 1 - Mz = M([[0, 0], [0, 0]]) - assert Mz.rank() == 0 - - -def test_matrices_rref(): - for M, _, is_field in _all_matrices(): - if is_field: - Mr = M([[1, 2, 3], [4, 5, 6]]) - Mr_rref = M([[1, 0, -1], [0, 1, 2]]) - assert Mr.rref() == (Mr_rref, 2) - assert Mr == M([[1, 2, 3], [4, 5, 6]]) - assert Mr.rref(inplace=True) == (Mr_rref, 2) - assert Mr == Mr_rref - - -def test_matrices_fflu(): - - QQ = flint.fmpq_mat - shape = lambda A: (A.nrows(), A.ncols()) - - def is_permutation(P): - if not P.is_square(): - return False - n = P.nrows() - for i, row in enumerate(sorted(P.tolist(), reverse=True)): - if row != [int(i == j) for j in range(n)]: - return False - return True - - def check_fflu(A): - m, n = shape(A) - P, L, D, U = A.fflu() - Dq = QQ(D) - assert P*A == L*Dq.inv()*U - assert shape(P) == shape(L) == shape(D) == (m, m) - assert shape(A) == shape(U) == (m, n) - assert is_permutation(P) - assert L.is_lower_triangular() - assert U.is_upper_triangular() - assert D.is_diagonal() - - for M, _, _ in _all_matrices(): - # XXX: Add this to more matrix types... - if M is not flint.fmpz_mat: - continue - - A = M([[1, 2], [3, 4]]) - P, L, D, U = A.fflu() - assert P == M([[1, 0], [0, 1]]) - assert L == M([[1, 0], [3, -2]]) - assert D == M([[1, 0], [0, -2]]) - assert U == M([[1, 2], [0, -2]]) - - check_fflu(M(0, 0, [])) - check_fflu(M(2, 0, [])) - check_fflu(M(0, 2, [])) - check_fflu(M([[1]])) - - check_fflu(M([[1, 2], [3, 4]])) - check_fflu(M([[1, 2, 3], [4, 5, 6]])) - check_fflu(M([[1, 2], [3, 4], [5, 6]])) - check_fflu(M([[1, 2], [2, 4]])) - check_fflu(M([[0, 0], [0, 0]])) - check_fflu(M([[1, 1, 1], [1, 1, 1]])) - - for _ in range(10): - for m in range(1, 5): - for n in range(1, 5): - A = M.randbits(m, n, 10) - check_fflu(A) - - -def test_matrices_solve(): - for M, _, is_field in _all_matrices(): - if is_field: - A = M([[1, 2], [3, 4]]) - x = M([[1], [2]]) - b = M([[5], [11]]) - assert A*x == b - assert A.solve(b) == x - A22 = M([[1, 2], [3, 4]]) - A23 = M([[1, 2, 3], [4, 5, 6]]) - b2 = M([[5], [11]]) - b3 = M([[5], [11], [17]]) - assert raises(lambda: A22.solve(b3), ValueError) - assert raises(lambda: A23.solve(b2), ValueError) - assert raises(lambda: A.solve(None), TypeError) - A = M([[1, 2], [2, 4]]) - assert raises(lambda: A.solve(b), ZeroDivisionError) - - -def test_matrices_transpose(): - for M, _, _ in _all_matrices(): - M1234 = M([[1, 2, 3], [4, 5, 6]]) - assert M1234.transpose() == M([[1, 4], [2, 5], [3, 6]]) - - -def test_fq_default(): - # test fq_default context creation - - # fq_type parsing - assert raises(lambda: flint.fq_default_ctx(5, fq_type="A"), ValueError) - assert raises(lambda: flint.fq_default_ctx(5, fq_type=[]), TypeError) - assert raises(lambda: flint.fq_default_ctx(5, fq_type=-1), ValueError) - assert raises(lambda: flint.fq_default_ctx("ABC"), TypeError) # type: ignore - - # p must be set if modulus has no characteristic / modulus - assert raises(lambda: flint.fq_default_ctx(modulus=[0,1,0]), ValueError) - - # prime must be prime when setting from modulus - assert raises(lambda: flint.fq_default_ctx(10, modulus=[0,1,0]), ValueError) - mod_not_prime = flint.fmpz_mod_poly_ctx(10)([1,0,1]) - assert raises(lambda: flint.fq_default_ctx(modulus=mod_not_prime), ValueError) - mod_not_irr = flint.fmpz_mod_poly_ctx(11)([0,0,1]) - assert raises(lambda: flint.fq_default_ctx(modulus=mod_not_irr), ValueError) - - # modulus must be able to be cast to fmpz_mod_poly - assert raises(lambda: flint.fq_default_ctx(11, modulus="AAA"), TypeError) - - # either p or modulus must be set - assert raises(lambda: flint.fq_default_ctx(p=None, modulus=None), ValueError) - - # p must be prime - assert raises(lambda: flint.fq_default_ctx(10), ValueError) - - # degree must be positive - assert raises(lambda: flint.fq_default_ctx(11, -1), ValueError) - - # GF(5) - gf_5 = flint.fq_default_ctx(5, fq_type='NMOD') - gf_5_ = flint.fq_default_ctx(5, fq_type='NMOD') - - # GF(5^2) - gf_5_2 = flint.fq_default_ctx(5, 2, fq_type='FQ_ZECH') - gf_5_2_ = flint.fq_default_ctx(5, 2, fq_type='FQ_ZECH') - - # GF((2**127 - 1)^2) - gf_127 = flint.fq_default_ctx(2**127 - 1, 2) - gf_127_2 = flint.fq_default_ctx(2**127 - 1, 2) - - assert (gf_5 == gf_5_) is True - assert (hash(gf_5) == hash(gf_5_)) is True - assert (gf_5 != gf_5_) is False - assert (gf_5 == gf_5_2) is False - assert (gf_5 != gf_5_2) is True - assert (gf_5 == "a") is False - assert (gf_5 != "a") is True - - assert gf_5.prime() == gf_5_2.prime() == 5 - assert gf_5_2.order() == 5*5 - assert gf_5_2.multiplicative_order() == 5*5 - 1 - assert gf_127_2.prime() == 2**127 - 1 - - assert gf_5_2(0) == gf_5_2.zero() - assert gf_5_2(1) == gf_5_2.one() - assert gf_5_2.gen() == gf_5_2([0, 1]) - - assert str(gf_5) == "Context for fq_default in GF(5)" - assert str(gf_5_2) == "Context for fq_default in GF(5^2)[z]/(z^2 + 4*z + 2)" - - assert repr(gf_5) == "fq_default_ctx(5, var='z', type='NMOD')" - assert repr(gf_5_2) == "fq_default_ctx(5, 2, 'z', x^2 + 4*x + 2, 'FQ_ZECH')" - - # coercision - assert gf_5.one() == flint.fq_default(1, gf_5) - assert gf_5(1) == gf_5.one() - assert gf_5(flint.fmpz(1)) == gf_5.one() - assert gf_5(-1) == -gf_5.one() - assert gf_5(flint.fmpz(-1)) == -gf_5.one() - R = flint.fmpz_mod_ctx(5) - assert gf_5(R(1)) == gf_5.one() - assert gf_5(R(-1)) == -gf_5.one() - assert gf_5(flint.nmod(1, 5)) == gf_5.one() - assert gf_5(flint.nmod(-1, 5)) == -gf_5.one() - assert gf_5([0, 1]) == gf_5.gen() - assert gf_5(flint.fmpz_poly([0, 1])) == gf_5.gen() - R = flint.fmpz_mod_poly_ctx(5) - assert gf_5.gen() == gf_5(R.gen()) - assert gf_5.gen() == gf_5(flint.nmod_poly([0, 1], 5)) - assert gf_5(flint.fmpz(2**64)) == gf_5(2**64) - assert raises(lambda: flint.fq_default(1, "AAA"), TypeError) # type: ignore - assert raises(lambda: flint.fq_default.__init__(1, "AAA"), TypeError) # type: ignore - assert raises(lambda: flint.fq_default("AAA", gf_5), TypeError) - assert raises(lambda: gf_5.one() + gf_5_2.one(), ValueError) - # testing various equalties between types - - # integers are the same if characteristic is the same - # even with extensions - assert gf_5.one() == gf_5_.one() - assert hash(gf_5.one()) == hash(gf_5_.one()) - assert gf_5.one() == gf_5_2.one() - assert gf_5.one() != gf_127.one() - - # the generators for different extensions - assert gf_5_2([0, 1]) != gf_5([0, 1]) - assert gf_5_2([0, 1]) == gf_5_2_([0, 1]) - assert gf_5_2([0, 1]) != gf_127_2([0, 1]) - - # integers are reduced modulo p before comparison - for int_type in [int, flint.fmpz]: - assert gf_5(1) == int_type(1) - assert gf_5(-1) == int_type(-1) - assert gf_5(-1) == int_type(4) - assert gf_5(4) == int_type(4) - assert gf_5(4) == int_type(-1) - - # integers modulo n also can be compared when they match - assert gf_5(1) == flint.nmod(1, 5) - assert gf_5(-1) == flint.nmod(-1, 5) - assert gf_5(-1) == flint.nmod(4, 5) - assert gf_5_2(1) == flint.nmod(1, 5) - assert gf_5_2(-1) == flint.nmod(-1, 5) - assert gf_5_2(-1) == flint.nmod(4, 5) - - # when the moduli dont match, comparison is always false - assert gf_5(1) != flint.nmod(1, 7) - assert gf_5(-1) != flint.nmod(-1, 7) - assert gf_5(-1) != flint.nmod(4, 7) - assert gf_5_2(1) != flint.nmod(1, 7) - assert gf_5_2(-1) != flint.nmod(-1, 7) - assert gf_5_2(-1) != flint.nmod(4, 7) - - # integers modulo n also can be compared when they match - R5 = flint.fmpz_mod_ctx(5) - assert gf_5(1) == R5(1) - assert gf_5(-1) == R5(-1) - assert gf_5(-1) == R5(4) - assert gf_5_2(1) == R5(1) - assert gf_5_2(-1) == R5(-1) - assert gf_5_2(-1) == R5(4) - - # when the moduli dont match, comparison is always false - R7 = flint.fmpz_mod_ctx(7) - assert gf_5(1) != R7(1) - assert gf_5(-1) != R7(-1) - assert gf_5(-1) != R7(4) - assert gf_5_2(1) != R7(1) - assert gf_5_2(-1) != R7(-1) - assert gf_5_2(-1) != R7(4) - - # test fq_default element arithmetic - - for gf in [gf_5, gf_5_2, gf_127, gf_127_2]: - - assert (gf(0) == gf.zero()) is True - assert (gf(0) != gf.zero()) is False - assert (gf(1) == gf.zero()) is False - assert (gf(1) != gf.zero()) is True - assert raises(lambda: gf.zero() > gf.zero(), TypeError) # type: ignore - assert raises(lambda: gf.zero() >= gf.zero(), TypeError) # type: ignore - assert raises(lambda: gf.zero() < gf.zero(), TypeError) # type: ignore - assert raises(lambda: gf.zero() <= gf.zero(), TypeError) # type: ignore - - assert gf.zero().is_zero() is True - assert gf.one().is_zero() is False - - assert gf.zero().is_one() is False - assert gf.one().is_one() is True - - a = gf.random_element(not_zero=True) - b = gf.random_element(not_zero=True) - c = gf.random_element(not_zero=True) - - assert a + (-a) == gf.zero() - assert a + a == 2*a - assert a * a == a**2 - assert a * a == a.square() - assert a * a * a == pow(a, 3) - - assert (a + b) + c == a + (b + c) - assert (a - b) - c == a - (b + c) - assert (a * b) * c == a * (b * c) - assert (a / b) / c == a / (b * c) - - assert a + 0 == 0 + a == a - assert a - 0 == -(0 - a) == a - assert a + gf.zero() == a - assert a * 1 == 1 * a == a - assert a * gf.one() == a - assert a * gf.zero() == gf.zero() - assert a / a == gf.one() - - assert raises(lambda: a / 0, ZeroDivisionError) - assert raises(lambda: ~gf.zero(), ZeroDivisionError) - assert raises(lambda: pow(gf.zero(), -1), ZeroDivisionError) - assert raises(lambda: pow(gf.zero(), "A"), TypeError) # type: ignore - - assert 1/a == pow(a, -1) == ~a - assert gf.one() == pow(a, 0) - assert gf.zero() == pow(gf.zero(), 2**64) - assert a == pow(a, 1) - assert pow(a, flint.fmpz(2**64)) == pow(a, 2**64) - assert (a*a).is_square() - assert (a*a).sqrt() in [a, -a] - - while True: - nqr = gf.random_element() - if not nqr.is_square(): - break - assert raises(lambda: nqr.sqrt(), DomainError) - - -def test_fq_default_poly(): - F = flint.fq_default_ctx(11, 3) - R1 = flint.fq_default_poly_ctx(F) - R2 = flint.fq_default_poly_ctx(11, 3) - R3 = flint.fq_default_poly_ctx(13, 5) - - assert raises(lambda: flint.fq_default_poly_ctx("AAA"), TypeError) # type: ignore - assert (R1 == R1) is True - assert hash(R1) == hash(R2) - assert (R1 != R1) is False - assert (R1 == R2) is True - assert (R1 != R2) is False - assert (R1 != R3) is True - assert (R1 == R3) is False - assert (R1 != "AAA") is True - assert (R1 == "AAA") is False - - assert str(R1) == "Context for fq_default_poly with field: Context for fq_default in GF(11^3)[z]/(z^3 + 2*z + 9)" - assert str(R1) == str(R2) - assert repr(R3) == "fq_default_poly_ctx(fq_default_ctx(13, 5, 'z', x^5 + 4*x + 11, 'FQ_NMOD'))" - - # random element failure - f = R1.random_element(not_zero=True) - assert not f.is_zero() - assert raises(lambda: R1.random_element(monic="AAA"), TypeError) # type: ignore - assert raises(lambda: R1.random_element(degree=-1), ValueError) - - assert raises(lambda: flint.fq_default_poly([1,2,3], "AAA"), TypeError) # type: ignore - - assert R1(0).leading_coefficient() == 0 - assert raises(lambda: R1.random_element().reverse(degree=-1), ValueError) - - # some coercion - assert raises(lambda: R3(F(1)), ValueError) - assert R1.one() == R1(1) - assert R1.one() == R1([1]) - assert R1.one() == R1(flint.fmpz(1)) - assert R1.one() == R1(flint.fmpz_poly([1])) - assert R1.one() == R1(flint.fmpz_mod_ctx(11)(1)) - assert R1.one() == R1(flint.fmpz_mod_poly_ctx(11)(1)) - assert R1.one() == R1(flint.nmod_poly(1, 11)) - - R_sml = flint.fq_default_poly_ctx(5) - R_med = flint.fq_default_poly_ctx(65537) - R_big = flint.fq_default_poly_ctx(2**127 - 1) - R_sml_ext = flint.fq_default_poly_ctx(5, 5) - R_med_ext = flint.fq_default_poly_ctx(65537, 3) - R_big_ext = flint.fq_default_poly_ctx(2**127 - 1, 2) - - F_cmp = flint.fq_default_ctx(11) - R_cmp = flint.fq_default_poly_ctx(F_cmp) - f_cmp = R_cmp([1,2,3,4,5]) - - for R_test in [R_sml, R_med, R_big, R_sml_ext, R_med_ext, R_big_ext]: - F_test = R_test.base_field() - while True: - nqr = F_test.random_element() - if not nqr.is_square(): - break - - f = R_test([-1,-2]) - g = R_test([-3,-4]) - assert (f == f) is True - assert (f != g) is True - assert (hash(f) == hash(f)) is True - assert (hash(f) != hash(g)) is True - - # Exact division - assert raises(lambda: f.exact_division(f_cmp), ValueError) - assert raises(lambda: f.exact_division("AAA"), TypeError) - assert raises(lambda: f.exact_division(0), ZeroDivisionError) - assert (f * g).exact_division(g) == f - assert raises(lambda: f.exact_division(g), DomainError) - assert raises(lambda: f / "AAA", TypeError) - assert raises(lambda: "AAA" / f, TypeError) - - # ZeroDivisionError - assert raises(lambda: f / 0, ZeroDivisionError) - assert raises(lambda: f // 0, ZeroDivisionError) - assert raises(lambda: 1 / R_test.zero(), ZeroDivisionError) - assert raises(lambda: 1 // R_test.zero(), ZeroDivisionError) - assert raises(lambda: 1 % R_test.zero(), ZeroDivisionError) - - # pow - # assert ui and fmpz exp agree for polynomials and generators - R_gen = R_test.gen() - assert raises(lambda: f**(-2), DomainError) - assert pow(f, 2**60, g) == pow(pow(f, 2**30, g), 2**30, g) - assert pow(R_gen, 2**60, g) == pow(pow(R_gen, 2**30, g), 2**30, g) - assert raises(lambda: pow(f, -2, g), ValueError) - assert raises(lambda: pow(f, 1, "A"), TypeError) - assert raises(lambda: pow(f, "A", g), TypeError) # type: ignore - assert raises(lambda: f.pow_mod(2**32, g, mod_rev_inv="A"), TypeError) # type: ignore - - # Shifts - assert raises(lambda: R_test([1,2,3]).left_shift(-1), ValueError) - assert raises(lambda: R_test([1,2,3]).right_shift(-1), ValueError) - assert R_test([1,2,3]).left_shift(3) == R_test([0,0,0,1,2,3]) - assert R_test([1,2,3]).right_shift(1) == R_test([2,3]) - - # mulmod - assert f.mul_mod(f, g) == (f*f) % g - assert raises(lambda: f.mul_mod(f, "AAA"), TypeError) - assert raises(lambda: f.mul_mod("AAA", g), TypeError) - - # pow_mod - assert f.pow_mod(2, g) == (f*f) % g - assert raises(lambda: f.pow_mod(2, "AAA"), TypeError) - - # roots - assert raises(lambda: f.real_roots(), DomainError) - assert raises(lambda: f.complex_roots(), DomainError) - - # compose errors - assert raises(lambda: f.compose("A"), TypeError) - assert raises(lambda: f.compose_mod("A", g), TypeError) - assert raises(lambda: f.compose_mod(g, "A"), TypeError) - assert raises(lambda: f.compose_mod(g, R_test.zero()), ZeroDivisionError) - - # inverse_mod - while True: - # Ensure f is invertible - f = R_test.random_element() - if not f.constant_coefficient().is_zero(): - break - while True: - h = R_test.random_element() - if f.gcd(h).is_one() and h.degree() >= 1: - break - g = f.inverse_mod(h) - assert f.mul_mod(g, h).is_one() - if f.degree() >= 1: - assert raises(lambda: f.inverse_mod(2*f), ValueError) - else: - assert f.inverse_mod(2*f) == 0 # ??? - - # series - f_non_square = R_test([nqr, 1, 1, 1]) - f_zero = R_test([0, 1, 1, 1]) - assert raises(lambda: f_non_square.sqrt_trunc(1), ValueError) - assert raises(lambda: f_zero.sqrt_trunc(1), ZeroDivisionError) - assert raises(lambda: f_non_square.inv_sqrt_trunc(1), ValueError) - assert raises(lambda: f_zero.inv_sqrt_trunc(1), ZeroDivisionError) - f_inv = f.inverse_series_trunc(2) - assert (f * f_inv) % R_test([0,0,1]) == 1 - assert raises(lambda: R_test([0,1]).inverse_series_trunc(2), ZeroDivisionError) - - # deflation - f1 = R_test([1,0,2,0,3]) - assert raises(lambda: f1.deflate(100), ValueError) - assert f1.deflate(2) == R_test([1,2,3]) - - # truncate things - f = R_test.random_element() - g = R_test.random_element() - h = R_test.random_element() - x = R_test.gen() - f_trunc = f % x**3 - - assert f.equal_trunc(f_trunc, 3) - assert not f.equal_trunc("A", 3) - assert not f.equal_trunc(f_cmp, 3) - - assert raises(lambda: f.add_trunc("A", 1), TypeError) - assert raises(lambda: f.add_trunc(f_cmp, 1), ValueError) - assert f.add_trunc(g, 3) == (f + g) % x**3 - - assert raises(lambda: f.sub_trunc("A", 1), TypeError) - assert raises(lambda: f.sub_trunc(f_cmp, 1), ValueError) - assert f.sub_trunc(g, 3) == (f - g) % x**3 - - assert raises(lambda: f.mul_low("A", 1), TypeError) - assert raises(lambda: f.mul_low(g, "A"), TypeError) # type: ignore - assert raises(lambda: f.mul_low(f_cmp, 1), ValueError) - assert f.mul_low(g, 3) == (f * g) % x**3 - - assert raises(lambda: f.pow_trunc(-1, 5), ValueError) - - -def test_python_threads(): - # - # https://github.com/flintlib/python-flint/issues/224 - # - # XXX: This test crashes under the free-threading mode because of memory - # corruption. - # - # It is not clear if this should be fixed or if mutating - # matrices/polynomials that are shared between multiple threads should just - # be disallowed. - # - # This thread is skipped on Emscripten/WASM builds as we can't start new - # threads in Pyodide. - - # Skip the test on the free-threaded build and on WASM... - import sys - if (sys.version_info[:2] >= (3, 13) and not sys._is_gil_enabled()) or ( # type: ignore - sys.platform == "emscripten" or platform.machine() in ["wasm32", "wasm64"]): - return - - from threading import Thread - - iterations = 10**5 - nthreads = 3 + 1 - size = 3 - M = flint.fmpz_mat([[0]*size for _ in range(size)]) - - def set_values(): - for i in range(iterations // 5): - i = random.randrange(M.nrows()) - j = random.randrange(M.ncols()) - if random.uniform(0, 1) > 0.5: - # Bigger than 2**62: - M[i,j] = 10**128 - else: - # Smaller than 2**62: - M[i,j] = 0 - - def get_dets(): - for _ in range(iterations): - M.det() - - threads = [Thread(target=set_values) for _ in range(nthreads-1)] - threads.append(Thread(target=get_dets)) - - for t in threads: - t.start() - for t in threads: - t.join() - - -def test_all_tests(): - test_funcs = {f for name, f in globals().items() if name.startswith("test_")} - untested = test_funcs - set(all_tests) - assert not untested, f"Untested functions: {untested}" - - -all_tests = [ - test_pyflint, - test_showgood, - - test_fmpz, - test_fmpz_factor, - test_fmpz_functions, - test_fmpz_poly, - test_fmpz_poly_factor, - test_fmpz_poly_functions, - test_fmpz_mat, - test_fmpz_series, - - test_fmpq, - test_fmpq_poly, - test_fmpq_mat, - test_fmpq_series, - - test_nmod, - test_nmod_poly, - test_nmod_mat, - test_nmod_series, - - test_fmpz_mod, - test_fmpz_mod_dlog, - test_fmpz_mod_poly, - test_fmpz_mod_mat, - - test_division_scalar, - test_division_poly, - test_division_matrix, - - test_properties_poly_mpoly, - test_factor_poly_mpoly, - test_division_poly_mpoly, - - test_polys, - test_mpolys_constructor, - test_mpolys_properties, - - test_poly_resultants, - - test_fmpz_mpoly_vec, - - test_matrices_eq, - test_matrices_constructor, - test_matrices_strrepr, - test_matrices_getitem, - test_matrices_setitem, - test_matrices_bool, - test_matrices_transpose, - test_matrices_pos_neg, - test_matrices_add, - test_matrices_sub, - test_matrices_mul, - test_matrices_pow, - test_matrices_div, - test_matrices_properties, - test_matrices_inv, - test_matrices_det, - test_matrices_charpoly, - test_matrices_minpoly, - test_matrices_rank, - test_matrices_rref, - test_matrices_solve, - test_matrices_fflu, - - test_fq_default, - test_fq_default_poly, - - test_arb, - test_acb, - - test_pickling, - - test_python_threads, - - test_all_tests, -] + arb_tests diff --git a/src/flint/test/test_arb.py b/src/flint/test/test_arb.py deleted file mode 100644 index 66fce5f2..00000000 --- a/src/flint/test/test_arb.py +++ /dev/null @@ -1,358 +0,0 @@ -"""Test for python-flint's `arb` type.""" - -import math - -from flint import arb, ctx - -def assert_almost_equal(x, y, places=7): - """Helper method for approximate comparisons.""" - assert round(x-y, ndigits=places) == 0 - -def test_from_int(): - """Tests instantiating `arb`s from ints.""" - for val in [ - -42 * 10**9, - -42 * 10**7, - -42, - 0, - 42, - 42 * 10**7, - 42 * 10**9, - 42 * 10**11, - ]: - x = arb(val) - man, exp = x.man_exp() - assert (man * 2**exp) == val - -def test_from_float(): - """Tests instantiating `arb`s from floats.""" - for val in [0.0, 1.1, -1.1, 9.9 * 0.123, 99.12]: - x = arb(val) - man, exp = x.man_exp() - assert (int(man) * 2 ** int(exp)) == val - -def test_from_float_inf(): - """Tests `arb` works with +/- inf.""" - posinf = arb(float("inf")) - neginf = arb(float("-inf")) - - assert not posinf.is_finite() - assert not neginf.is_finite() - assert float(posinf) == float("inf") - assert float(neginf) == float("-inf") - -def test_from_man_exp(): - """Tests instantiating `arb`s with mantissa and exponent.""" - for man, exp in [(2, 30), (4, 300), (5 * 10**2, 7**8)]: - x = arb(mid=(man, exp)) - m, e = x.man_exp() - assert (m * 2**e) == (man * 2**exp) - -def test_from_midpoint_radius(): - """Tests instantiating `arb`s with midpoint and radius.""" - for mid, rad in [(10, 1), (10000, 5), (10, 1), (10, 1)]: - mid_arb = arb(mid) - rad_arb = arb(rad) - x = arb(mid_arb, rad_arb) - assert x.mid() == mid_arb - actual_radius = float(x.rad()) - assert_almost_equal(actual_radius, rad) - -def test_is_exact(): - """Tests `arb.is_exact`.""" - for arb_val, exact in [ - (arb(10), True), - (arb(0.01), True), - (arb(-float("inf")), True), - (arb(1, 0), True), - (arb(1, 1), False), - ]: - assert arb_val.is_exact() == exact - -def test_is_finite(): - """Tests `arb.is_finite`.""" - assert not (arb(-float("inf")).is_finite()) - assert not (arb(float("inf")).is_finite()) - assert (arb(10).is_finite()) - -def test_is_nan(): - """Tests `arb.is_nan`.""" - assert (arb(float("nan")).is_nan()) - assert not (arb(0.0).is_nan()) - -def test_lower(): - """Tests `arb.lower`.""" - with ctx.workprec(100): - arb_val = arb(1, 0.5) - assert_almost_equal(float(arb_val.lower()), 0.5) - -def test_upper(): - """Tests `arb.upper`.""" - with ctx.workprec(100): - arb_val = arb(1, 0.5) - assert_almost_equal(float(arb_val.upper()), 1.5) - -def test_contains(): - """`y.__contains__(x)` returns True iff every number in `x` is also in `y`.""" - for x, y, expected in [ - ( - arb(mid=9, rad=1), - arb(mid=10, rad=2), - True, - ), - ( - arb(mid=10, rad=2), - arb(mid=9, rad=1), - False, - ), - (arb(10), arb(mid=9, rad=1), True), - (arb(10.1), arb(mid=9, rad=1), False), - ]: - assert (x in y) == expected - -def test_hash(): - """`x` and `y` hash to the same value if they have the same midpoint and radius. - - Args: - x: An arb. - y: An arb. - expected: Whether `x` and `y` should hash to the same value. - """ - def arb_pi(prec): - """Helper to calculate arb to a given precision.""" - with ctx.workprec(prec): - return arb.pi() - for x, y, expected in [ - (arb(10), arb(10), True), - (arb(10), arb(11), False), - (arb(10.0), arb(10), True), - ]: - assert (hash(x) == hash(y)) == expected - - for x in [ - arb(mid=10, rad=2), - arb_pi(100), - ]: - try: - hash(x) - except ValueError: - pass - else: - assert False, f"Expected {x} to raise an error if hashed, but succeeded." - - - -# Tests for arithmetic functions in `flint.arb`. - -# NOTE: Correctness of an arb function `F` is specified as follows: - -# If `f` is the corresponding real-valued arithmetic function, `F` is correct -# only if, for any Arb X and any real number x in the interval X, -# `f(x)` is in `F(X)`. - -# These tests assume arb.__contains__ is correct. - -def test_arb_sub(): - """`arb.__sub__` works as expected.""" - arb1 = arb(2, 0.5) - arb2 = arb(1, 1) - with ctx.workprec(100): - actual = arb1 - arb2 - # Smallest value in diff => 1.5 - 2 = -0.5 - # Largest value in diff => 2.5 - 0 = 2.5 - true_interval = arb(1, 1.5) # [-0.5, 2.5] - assert true_interval in actual - -def test_arb_add(): - """`arb.__add__` works as expected.""" - arb1 = arb(2, 1) - arb2 = arb(1, 1) - with ctx.workprec(100): - actual = arb1 + arb2 - true_interval = arb(3, 2) # [1, 5] - assert true_interval in actual - -def test_arb_mul(): - """`arb.__mul__` works as expected.""" - arb1 = arb(2, 1) - arb2 = arb(1, 1) - with ctx.workprec(100): - actual = arb1 * arb2 - true_interval = arb(3, 3) # [0, 6] - assert true_interval in actual - -def test_arb_div(): - """`arb.__div__` works as expected.""" - arb1 = arb(4, 1) - arb2 = arb(2, 1) - with ctx.workprec(100): - actual = arb1 / arb2 - true_interval = arb(4, 1) # [3, 5] - assert true_interval in actual - -def test_arb_log(): - """`arb.log` works as expected.""" - midpoint = (1 + math.exp(10)) / 2 - arb_val = arb(midpoint, midpoint - 1) # [1, exp(10)] - with ctx.workprec(100): - actual = arb_val.log() - true_interval = arb(5, 5) # [0,10] - assert true_interval in actual - -def test_arb_exp(): - """`arb.exp` works as expected.""" - midpoint = math.log(9) / 2 - arb_val = arb(midpoint, midpoint) # [0, log(9)] - with ctx.workprec(100): - actual = arb_val.exp() - true_interval = arb(5, 4) # [1,9] - assert true_interval in actual - -def test_arb_max(): - """`arb.max` works as expected.""" - arb1 = arb(1.5, 0.5) # [1, 2] - arb2 = arb(1, 2) # [-1, 3] - with ctx.workprec(100): - actual = arb1.max(arb2) - true_interval = arb(2, 1) # [1, 3] - assert true_interval in actual - -def test_arb_min(): - """`arb.min` works as expected.""" - arb1 = arb(1.5, 0.5) # [1, 2] - arb2 = arb(1, 2) # [-1, 3] - with ctx.workprec(100): - actual = arb1.min(arb2) - true_interval = arb(0.5, 1.5) # [-1, 2] - assert true_interval in actual - -def test_arb_abs(): - """`arb.__abs__` works as expected.""" - arb_val = arb(1, 2) # [-1,3] - actual = abs(arb_val) - true_interval = arb(1.5, 1.5) - assert true_interval in actual - -def test_arb_neg(): - """`arb.neg` works as expected.""" - arb_val = arb(1, 2) # [-1,3] - actual = arb_val.neg(exact=True) - true_interval = arb(-2, 1) # [-3,1] - assert true_interval in actual - -def test_arb_neg_dunder(): - """`arb.__neg__` works as expected.""" - arb_val = arb(1, 2) # [-1,3] - actual = -arb_val - true_interval = arb(-2, 1) # [-3,1] - assert true_interval in actual - -def test_arb_sgn(): - """`arb.sgn` works as expected.""" - arb1 = arb(1, 0.5) # [0.5,1.5] - arb2 = arb(-1, 0.5) # [-1.5,-0.5] - arb3 = arb(1, 2) # [-1,3] - assert_almost_equal(float(arb1.sgn()), 1) - assert_almost_equal(float(arb2.sgn()), -1) - # arb3 contains both positive and negative numbers - # So, arb_sgn returns [0, 1] - assert_almost_equal(float(arb3.sgn().mid()), 0) - assert_almost_equal(float(arb3.sgn().rad()), 1) - -def test_arb_erfinv(): - """`arb.erfinv` works as expected.""" - midpoint = (math.erf(1 / 8) + math.erf(1 / 16)) / 2 - radius = midpoint - math.erf(1 / 16) - arb_val = arb(midpoint, radius) - with ctx.workprec(100): - actual = arb_val.erfinv() - true_interval = arb(3 / 32, 1 / 32) # [1/16, 1/8] - assert true_interval in actual - -def test_arb_erf(): - """`arb.erf` works as expected.""" - arb_val = arb(2, 1) - with ctx.workprec(100): - actual = arb_val.erf() - true_interval = arb( - (math.erf(1) + math.erf(3)) / 2, - (math.erf(1) + math.erf(3)) / 2 - math.erf(1) - ) - assert true_interval in actual - -def test_arb_erfc(): - """`arb.erfc` works as expected.""" - arb_val = arb(2, 1) - with ctx.workprec(100): - actual = arb_val.erfc() - true_interval = arb( - (math.erfc(1) + math.erfc(3)) / 2, - (math.erfc(1) + math.erfc(3)) / 2 - math.erfc(3) - ) - assert true_interval in actual - -def test_arb_const_pi(): - """`arb.pi` works as expected.""" - with ctx.workprec(100): - actual = arb.pi() - interval_around_pi = arb(math.pi, 1e-10) - assert actual in interval_around_pi - -def test_arb_union(): - """`arb.union` works as expected.""" - arb1 = arb(1, 0.5) # [0.5,1.5] - arb2 = arb(3, 0.5) # [2.5,3.5] - with ctx.workprec(100): - actual = arb1.union(arb2) - true_interval = arb(2, 1.5) # [0.5, 3.5] - assert true_interval in actual - -def test_arb_sum(): - """`arb.__sum__` works as expected.""" - arb1 = arb(1, 0.5) # [0.5,1.5] - arb2 = arb(2, 0.5) # [1.5,2.5] - arb3 = arb(3, 0.5) # [2.5,3.5] - with ctx.workprec(100): - actual = arb1 + arb2 + arb3 - true_interval = arb(6, 1.5) # [4.5, 7.5] - assert true_interval in actual - -def test_no_tests_missing(): - """Make sure all arb tests are included in all_tests.""" - test_funcs = {f for name, f in globals().items() if name.startswith("test_")} - untested = test_funcs - set(all_tests) - assert not untested, f"Untested functions: {untested}" - -all_tests = [ - test_no_tests_missing, - test_from_int, - test_from_float, - test_from_float_inf, - test_from_man_exp, - test_from_midpoint_radius, - test_is_exact, - test_is_finite, - test_is_nan, - test_lower, - test_upper, - test_contains, - test_hash, - test_arb_sub, - test_arb_add, - test_arb_mul, - test_arb_div, - test_arb_log, - test_arb_exp, - test_arb_max, - test_arb_min, - test_arb_abs, - test_arb_neg, - test_arb_neg_dunder, - test_arb_sgn, - test_arb_erfinv, - test_arb_erf, - test_arb_erfc, - test_arb_const_pi, - test_arb_union, - test_arb_sum, -] \ No newline at end of file diff --git a/src/flint/test/test_docstrings.py b/src/flint/test/test_docstrings.py deleted file mode 100644 index d5b5a51d..00000000 --- a/src/flint/test/test_docstrings.py +++ /dev/null @@ -1,110 +0,0 @@ -import doctest -import importlib -import pkgutil -import re - -import flint - -dunder_test_regex = re.compile(r'^(.*?)__test__\.(.*?) \(line (\d+)\)$') - -test_flint_at_least = { - "flint.types._gr.gr_ctx.gens": 30100, - "flint.types._gr.gr_ctx.neg": 30100, - "flint.types.acb_theta.acb_theta": 30300, -} - - -def find_doctests(module): - finder = doctest.DocTestFinder() - tests = [] - tests_seen = set() - for module_info in pkgutil.walk_packages(module.__path__, flint.__name__ + "."): - try: - module = importlib.import_module(module_info.name) - - res = [] - for test in filter(lambda x: bool(x.examples), finder.find(module)): - - m = dunder_test_regex.match(test.name) - if m is not None: - groups = m.groups() - test.name = groups[0] + groups[1] - test.lineno = int(groups[2]) - - # Prefer the __test__ version of the test (remove the other) - if test.name in tests_seen: - n = len(res) - res = [r for r in res if r.name != test.name] - if len(res) != n - 1: - raise Exception(f"Duplicate test name: {test.name}") - tests_seen.remove(test.name) - - # Doctests that fail without latest flint - if test.name in test_flint_at_least: - if test_flint_at_least[test.name] > flint.__FLINT_RELEASE__: - continue - - if test.name not in tests_seen: - tests_seen.add(test.name) - res.append(test) - - tests.append((module_info.name, res)) - - except Exception as e: - print(f"Error importing {module_info.name}: {e}") - return tests - - -# The below definitions are only useful when pytest is a) installed, and b) being currently run. -# We don't want to impose pytest on those that just want to use `python -m flint.test` -try: - import pytest - - class PyTestDocTestRunner(doctest.DocTestRunner): - def report_failure(self, out, test, example, got): - pytest.fail( - "\n".join([ - f"{test.name}, line: {test.lineno}", - "Failed example:", - f"\t{example.source.strip()}", - "Expected:", - f"\t{example.want.strip()}", - "Got:", - f"\t{got.strip()}" - ]), - pytrace=False, - ) - - def report_unexpected_exception(self, out, test, example, exc_info): - pytest.fail( - "\n".join([ - f"{test.name}, line: {test.lineno}", - "Failed example:", - f"\t{example.source.strip()}", - "Exception raised:", - doctest._indent(doctest._exception_traceback(exc_info)) - ]), - pytrace=False, - ) - - runner = PyTestDocTestRunner() - - @pytest.mark.parametrize( - "test", - [ - test for _, test_set in find_doctests(flint) - for test in test_set - ], - ids=lambda test: test.name, - ) - def test_docstrings(test): - runner.run(test) - -except ImportError: - class PyTestDocTestRunner(doctest.DocTestRunner): - pass - - runner = None - - def test_docstrings(test): - pass diff --git a/src/flint/types/__init__.py b/src/flint/types/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/types/_gr.pxd b/src/flint/types/_gr.pxd deleted file mode 100644 index 3de00a5e..00000000 --- a/src/flint/types/_gr.pxd +++ /dev/null @@ -1,1878 +0,0 @@ -cimport cython -cimport libc.stdlib - -from flint.flintlib.types.flint cimport ( - slong, - ulong, - fmpz_t, -) -from flint.flintlib.types.fmpz cimport ( - fmpz_poly_t, -) -from flint.flintlib.types.fmpq cimport ( - fmpq_poly_t, -) -from flint.flintlib.types.mpoly cimport ( - ordering_t, -) -from flint.flintlib.functions.ulong_extras cimport ( - n_is_prime, -) -from flint.flintlib.functions.fmpz cimport ( - fmpz_init_set, -) -from flint.flintlib.functions.fmpz_poly cimport ( - fmpz_poly_init, - fmpz_poly_set, -) -from flint.flintlib.functions.fmpq_poly cimport ( - fmpq_poly_init, - fmpq_poly_set, -) - - -from flint.flintlib.types.gr cimport ( - truth_t, - T_TRUE, - T_FALSE, - T_UNKNOWN, - - GR_SUCCESS, - GR_DOMAIN, - GR_UNABLE, - - gr_ctx_t, - gr_ptr, - gr_vec_t, -) -from flint.flintlib.functions.gr_domains cimport ( - gr_ctx_init_fmpz, - gr_ctx_init_fmpq, - gr_ctx_init_fmpzi, - gr_ctx_init_fexpr, - - gr_ctx_init_nmod, - gr_ctx_init_fmpz_mod, - # gr_ctx_set_is_field, - - gr_ctx_init_fq, - gr_ctx_init_fq_nmod, - gr_ctx_init_fq_zech, - - gr_ctx_init_nf, - gr_ctx_init_nf_fmpz_poly, - - gr_ctx_init_real_qqbar, - gr_ctx_init_complex_qqbar, - # _gr_ctx_qqbar_set_limits, - - gr_ctx_init_real_ca, - gr_ctx_init_complex_ca, - gr_ctx_init_real_algebraic_ca, - gr_ctx_init_complex_algebraic_ca, - gr_ctx_init_complex_extended_ca, - - gr_ctx_init_real_float_arf, - gr_ctx_init_complex_float_acf, - - gr_ctx_init_real_arb, - gr_ctx_init_complex_acb, - - gr_ctx_init_gr_poly, - gr_ctx_init_gr_mpoly, - # gr_ctx_init_fmpz_mpoly_q, - # gr_ctx_init_series_mod_gr_poly, - gr_ctx_init_gr_series, -) -from flint.flintlib.functions.gr cimport ( - gr_heap_init, - gr_set_d, - gr_set_other, - gr_set_str, - gr_get_str, - gr_set, - gr_set_si, - gr_get_si, - - gr_zero, - gr_one, - gr_gen, - gr_gens, - # gr_gens_recursive, - gr_ctx_set_gen_names, - - gr_i, - gr_pos_inf, - gr_neg_inf, - gr_uinf, - gr_undefined, - gr_unknown, - - gr_is_zero, - gr_is_one, - gr_is_neg_one, - gr_is_integer, - gr_is_rational, - - gr_equal, - - gr_neg, - gr_add, - gr_add_si, - gr_add_other, - gr_other_add, - gr_sub, - gr_sub_si, - gr_sub_other, - gr_other_sub, - gr_mul, - gr_mul_si, - gr_mul_other, - gr_other_mul, - gr_is_invertible, - gr_inv, - gr_div, - gr_div_si, - gr_div_other, - gr_div_nonunique, - gr_divides, - gr_other_div, - gr_divexact, - gr_divexact_si, - gr_divexact_other, - gr_other_divexact, - gr_euclidean_div, - gr_euclidean_rem, - gr_euclidean_divrem, - gr_pow, - gr_pow_si, - gr_pow_other, - gr_other_pow, - - gr_is_square, - gr_sqrt, - gr_rsqrt, - - gr_gcd, - gr_lcm, - gr_factor, - - gr_floor, - gr_ceil, - gr_trunc, - gr_nint, - - gr_abs, - gr_conj, - gr_re, - gr_im, - gr_sgn, - gr_csgn, - gr_arg, - - gr_cmp, - gr_cmp_other, - gr_cmpabs, - gr_cmpabs_other, - gr_le, - gr_lt, - gr_ge, - gr_gt, - gr_abs_le, - gr_abs_lt, - gr_abs_ge, - gr_abs_gt, - gr_min, - gr_max, - - gr_numerator, - gr_denominator, -) -from flint.flintlib.functions.gr_vec cimport ( - gr_vec_init, - gr_vec_clear, - gr_vec_length, - gr_vec_entry_ptr, -) - -from flint.flint_base.flint_base cimport ( - flint_ctx, - flint_scalar, - ordering_py_to_c, -) - -from flint.types.fmpz cimport fmpz -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq_poly cimport fmpq_poly - - -# XXX: Can't import from Python modules in a .pxd file -# from flint.utils.flint_exceptions import DomainError, UnableError, UknownError - - -cdef inline truth_to_py(truth_t t): - if t == T_TRUE: - return True - elif t == T_FALSE: - return False - else: - return None - - -cdef inline truth_to_bool(truth_t t): - if t == T_TRUE: - return True - elif t == T_FALSE: - return False - else: - # raise UnknownError("Unknown truth value") - raise AssertionError("Unknown truth value") - - -@cython.no_gc -cdef class gr_ctx(flint_ctx): - cdef gr_ctx_t ctx_t - cdef bint _init - - @cython.final - cdef inline gr new_gr(self): - cdef gr py_val - cdef gr_ptr pval - pval = gr_heap_init(self.ctx_t) - if pval == NULL: - raise MemoryError("Failed to allocate memory for gr object") - py_val = gr.__new__(gr) - py_val.pval = pval - py_val.ctx = self - py_val._init = True - return py_val - - @cython.final - cdef inline gr from_d(self, double d): - cdef gr py_val - py_val = self.new_gr() - err = gr_set_d(py_val.pval, d, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Incorrect conversion from a double") - return py_val - - @cython.final - cdef inline gr from_other(self, gr x): - cdef gr py_val - py_val = self.new_gr() - err = gr_set_other(py_val.pval, x.pval, x.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot convert x to the current context") - return py_val - - @cython.final - cdef inline gr from_str(self, s: str): - cdef gr py_val - cdef bytes b - b = s.encode('utf-8') - py_val = self.new_gr() - err = gr_set_str(py_val.pval, b, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to parse string") - return py_val - - @cython.final - cdef inline gr from_si(self, slong n): - cdef gr py_val - py_val = self.new_gr() - err = gr_set_si(py_val.pval, n, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to parse string") - return py_val - - @cython.final - cdef inline str to_str(self, val: gr): - cdef str py_str - cdef char *s - err = gr_get_str(&s, val.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to convert to string") - py_str = (s).decode("utf-8") - # XXX: Is this a memory leak? - # flint_free(s) - return py_str - - @cython.final - cdef inline _error(self, int err, str msg): - if err & GR_DOMAIN: - # return DomainError(msg) - return AssertionError(msg) - elif err & GR_UNABLE: - # return UnableError(msg) - return AssertionError(msg) - else: - return AssertionError("Bad error code") - - @cython.final - cdef inline gr _zero(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_zero(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create zero") - return res - - @cython.final - cdef inline gr _one(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_one(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create one") - return res - - @cython.final - cdef inline gr _i(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_i(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create sqrt(-1)") - return res - - @cython.final - cdef inline gr _pos_inf(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_pos_inf(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create +inf") - return res - - @cython.final - cdef inline gr _neg_inf(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_neg_inf(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create -inf") - return res - - @cython.final - cdef inline gr _uinf(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_uinf(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create uinf") - return res - - @cython.final - cdef inline gr _undefined(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_undefined(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create undefined") - return res - - @cython.final - cdef inline gr _unknown(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_unknown(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create unknown") - return res - - @cython.final - cdef inline gr _gen(self): - cdef int err - cdef gr res = self.new_gr() - err = gr_gen(res.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot create generator") - return res - - @cython.final - cdef inline list _gens(self): - cdef int err - cdef gr g - cdef gr_vec_t gens - gr_vec_init(gens, 0, self.ctx_t) - err = gr_gens(gens, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot get generators") - length = gr_vec_length(gens, self.ctx_t) - py_gens = [None] * length - for 0 <= i < length: - g = self.new_gr() - err = gr_set(g.pval, gr_vec_entry_ptr(gens, i, self.ctx_t), self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to copy generator.") - py_gens[i] = g - gr_vec_clear(gens, self.ctx_t) - return py_gens - - @cython.final - cdef inline truth_t _is_zero(self, gr x): - return gr_is_zero(x.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _is_one(self, gr x): - return gr_is_one(x.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _is_neg_one(self, gr x): - return gr_is_neg_one(x.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _equal(self, gr x, gr y): - return gr_equal(x.pval, y.pval, self.ctx_t) - - # @cython.final - # cdef inline truth_t _is_integer(self, gr x): - # return gr_is_integer(x.pval, self.ctx_t) - # - # @cython.final - # cdef inline truth_t _is_rational(self, gr x): - # return gr_is_rational(x.pval, self.ctx_t) - - @cython.final - cdef inline gr _neg(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_neg(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot negate x in this context") - return res - - @cython.final - cdef inline gr _add(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_add(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot add x and y in this context") - return res - - @cython.final - cdef inline gr _add_other(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_add_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot add x and y in this context") - return res - - @cython.final - cdef inline gr _other_add(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_other_add(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot add x and y in this context") - return res - - @cython.final - cdef inline gr _add_si(self, gr x, slong y): - cdef int err - cdef gr res = self.new_gr() - err = gr_add_si(res.pval, x.pval, y, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot add x and y in this context") - return res - - @cython.final - cdef inline gr _sub(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_sub(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot sub x and y in this context") - return res - - @cython.final - cdef inline gr _sub_other(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_sub_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot sub x and y in this context") - return res - - @cython.final - cdef inline gr _other_sub(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_other_sub(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot sub x and y in this context") - return res - - @cython.final - cdef inline gr _sub_si(self, gr x, slong y): - cdef int err - cdef gr res = self.new_gr() - err = gr_sub_si(res.pval, x.pval, y, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot sub x and y in this context") - return res - - @cython.final - cdef inline gr _mul(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_mul(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot mul x and y in this context") - return res - - @cython.final - cdef inline gr _mul_other(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_mul_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot mul x and y in this context") - return res - - @cython.final - cdef inline gr _other_mul(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_other_mul(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot mul x and y in this context") - return res - - @cython.final - cdef inline gr _mul_si(self, gr x, slong y): - cdef int err - cdef gr res = self.new_gr() - err = gr_mul_si(res.pval, x.pval, y, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot mul x and y in this context") - return res - - ### - # Division - - @cython.final - cdef inline truth_t _is_invertible(self, gr x): - return gr_is_invertible(x.pval, self.ctx_t) - - @cython.final - cdef inline gr _inv(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_inv(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "x in not invertible in this context") - return res - - @cython.final - cdef inline gr _div(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_div(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot div x and y in this context") - return res - - @cython.final - cdef inline gr _div_other(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_div_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot div x and y in this context") - return res - - @cython.final - cdef inline gr _other_div(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_other_div(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot div x and y in this context") - return res - - @cython.final - cdef inline gr _div_si(self, gr x, slong y): - cdef int err - cdef gr res = self.new_gr() - err = gr_div_si(res.pval, x.pval, y, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot div x and y in this context") - return res - - @cython.final - cdef inline gr _divexact(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_divexact(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot divexact x and y in this context") - return res - - @cython.final - cdef inline gr _divexact_other(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_divexact_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot divexact x and y in this context") - return res - - @cython.final - cdef inline gr _other_divexact(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_other_divexact(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot divexact x and y in this context") - return res - - @cython.final - cdef inline gr _divexact_si(self, gr x, slong y): - cdef int err - cdef gr res = self.new_gr() - err = gr_divexact_si(res.pval, x.pval, y, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot divexact x and y in this context") - return res - - @cython.final - cdef inline gr _div_nonunique(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_div_nonunique(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "No solution q to x = qy has been found") - return res - - @cython.final - cdef inline truth_t _divides(self, gr x, gr d): - return gr_divides(x.pval, d.pval, self.ctx_t) - - @cython.final - cdef inline gr _euclidean_div(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_euclidean_div(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "No solution q to x = qy has been found") - return res - - @cython.final - cdef inline gr _euclidean_rem(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_euclidean_rem(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "No solution q to x = qy has been found") - return res - - @cython.final - cdef inline tuple[gr, gr] _euclidean_divrem(self, gr x, gr y): - cdef int err - cdef gr rem = self.new_gr() - cdef gr div = self.new_gr() - err = gr_euclidean_divrem(div.pval, rem.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "No solution q to x = qy has been found") - return (div, rem) - - ### - # Powering - - @cython.final - cdef inline gr _pow(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_pow(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - @cython.final - cdef inline gr _pow_other(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_pow_other(res.pval, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - @cython.final - cdef inline gr _other_pow(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_other_pow(res.pval, x.pval, x.ctx.ctx_t, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - @cython.final - cdef inline gr _pow_si(self, gr x, slong y): - cdef int err - cdef gr res = self.new_gr() - err = gr_pow_si(res.pval, x.pval, y, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - ### - # Square roots - - @cython.final - cdef inline truth_t _is_square(self, gr x): - return gr_is_square(x.pval, self.ctx_t) - - @cython.final - cdef inline gr _sqrt(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_sqrt(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - @cython.final - cdef inline gr _rsqrt(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_rsqrt(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - ### - # Greates Common Divisors - - @cython.final - cdef inline gr _gcd(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_gcd(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - @cython.final - cdef inline gr _lcm(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_lcm(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - ### - # Factorization - - @cython.final - cdef inline tuple[gr, list[tuple[gr, int]]] _factor(self, gr x): - cdef int err, i - cdef slong length, exp_s - cdef gr c, f - cdef gr_ptr fac_i, exp_i - cdef gr_vec_t factors, exponents - cdef int flags = 0 # XXX: What is flags? - c = self.new_gr() - gr_vec_init(factors, 0, self.ctx_t) - gr_vec_init(exponents, 0, gr_fmpz_ctx_c.ctx_t) - err = gr_factor(c.pval, factors, exponents, x.pval, flags, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to factor gr object") - length = gr_vec_length(factors, self.ctx_t) - py_factors = [None] * length - for 0 <= i < length: - f = self.new_gr() - fac_i = gr_vec_entry_ptr(factors, i, self.ctx_t) - err = gr_set(f.pval, fac_i, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to copy factor.") - exp_i = gr_vec_entry_ptr(exponents, i, gr_fmpz_ctx_c.ctx_t) - err = gr_get_si(&exp_s, exp_i, gr_fmpz_ctx_c.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to get integer value of exponent.") - exp = exp_s - py_factors[i] = (f, exp) - gr_vec_clear(factors, self.ctx_t) - gr_vec_clear(exponents, gr_fmpz_ctx_c.ctx_t) - return c, py_factors - - ### - # Fractions - - @cython.final - cdef inline gr _numerator(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_numerator(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - @cython.final - cdef inline gr _denominator(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_denominator(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot pow x and y in this context") - return res - - ### - # Integer and Complex parts - - @cython.final - cdef inline gr _floor(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_floor(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute floor(x) in this context") - return res - - @cython.final - cdef inline gr _ceil(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_ceil(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute ceil(x) in this context") - return res - - @cython.final - cdef inline gr _trunc(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_trunc(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute trunc(x) in this context") - return res - - @cython.final - cdef inline gr _nint(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_nint(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute nint(x) in this context") - return res - - @cython.final - cdef inline gr _abs(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_abs(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute abs(x) in this context") - return res - - @cython.final - cdef inline gr _conj(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_conj(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute conj(x) in this context") - return res - - @cython.final - cdef inline gr _re(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_re(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute re(x) in this context") - return res - - @cython.final - cdef inline gr _im(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_im(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute im(x) in this context") - return res - - @cython.final - cdef inline gr _sgn(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_sgn(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute sgn(x) in this context") - return res - - @cython.final - cdef inline gr _csgn(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_csgn(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute csgn(x) in this context") - return res - - @cython.final - cdef inline gr _arg(self, gr x): - cdef int err - cdef gr res = self.new_gr() - err = gr_arg(res.pval, x.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute arg(x) in this context") - return res - - ### - # Ordering methods - - @cython.final - cdef inline int _cmp(self, gr x, gr y): - cdef int err - cdef int res - err = gr_cmp(&res, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compare x and y") - return res - - @cython.final - cdef inline int _cmp_other(self, gr x, gr y): - cdef int err - cdef int res - err = gr_cmp_other(&res, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compare x and y") - return res - - @cython.final - cdef inline int _cmpabs(self, gr x, gr y): - cdef int err - cdef int res - err = gr_cmpabs(&res, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compare x and y") - return res - - @cython.final - cdef inline int _cmpabs_other(self, gr x, gr y): - cdef int err - cdef int res - err = gr_cmpabs_other(&res, x.pval, y.pval, y.ctx.ctx_t, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compare x and y") - return res - - @cython.final - cdef inline truth_t _le(self, gr x, gr y): - return gr_le(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _abs_le(self, gr x, gr y): - return gr_abs_le(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _lt(self, gr x, gr y): - return gr_lt(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _abs_lt(self, gr x, gr y): - return gr_abs_lt(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _ge(self, gr x, gr y): - return gr_ge(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _abs_ge(self, gr x, gr y): - return gr_abs_ge(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _gt(self, gr x, gr y): - return gr_gt(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline truth_t _abs_gt(self, gr x, gr y): - return gr_abs_gt(x.pval, y.pval, self.ctx_t) - - @cython.final - cdef inline gr _min(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_min(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute min(x) in this context") - return res - - @cython.final - cdef inline gr _max(self, gr x, gr y): - cdef int err - cdef gr res = self.new_gr() - err = gr_max(res.pval, x.pval, y.pval, self.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Cannot compute min(x) in this context") - return res - - # @cython.final - # cdef inline list _gens_recursive(self): - # cdef int err - # cdef gr g - # cdef gr_vec_t gens - # gr_vec_init(gens, 0, self.ctx_t) - # err = gr_gens_recursive(gens, self.ctx_t) - # if err != GR_SUCCESS: - # raise self._error(err, "Cannot get recursive generators") - # length = gr_vec_length(gens, self.ctx_t) - # py_gens = [None] * length - # for 0 <= i < length: - # g = self.new_gr() - # err = gr_set(g.pval, gr_vec_entry_ptr(gens, i, self.ctx_t), self.ctx_t) - # if err != GR_SUCCESS: - # raise self._error(err, "Failed to copy generator.") - # py_gens[i] = g - # gr_vec_clear(gens, self.ctx_t) - # return py_gens - - -cdef class gr_scalar_ctx(gr_ctx): - pass - - -cdef class gr_poly_ctx(gr_ctx): - pass - - -cdef class gr_mpoly_ctx(gr_ctx): - pass - - -# cdef class gr_matrix_domain_ctx(gr_ctx): -# pass - - -# cdef class gr_matrix_space_ctx(gr_ctx): -# pass - - -# cdef class gr_matrix_ring_ctx(gr_ctx): -# pass - - -@cython.no_gc -cdef class _gr_fmpz_ctx(gr_scalar_ctx): - - @staticmethod - cdef inline _gr_fmpz_ctx _new(): - cdef _gr_fmpz_ctx ctx - ctx = _gr_fmpz_ctx.__new__(_gr_fmpz_ctx) - gr_ctx_init_fmpz(ctx.ctx_t) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class _gr_fmpq_ctx(gr_scalar_ctx): - - @staticmethod - cdef inline _gr_fmpq_ctx _new(): - cdef _gr_fmpq_ctx ctx - ctx = _gr_fmpq_ctx.__new__(_gr_fmpq_ctx) - gr_ctx_init_fmpq(ctx.ctx_t) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class _gr_fmpzi_ctx(gr_scalar_ctx): - - @staticmethod - cdef inline _gr_fmpzi_ctx _new(): - cdef _gr_fmpzi_ctx ctx - ctx = _gr_fmpzi_ctx.__new__(_gr_fmpzi_ctx) - gr_ctx_init_fmpzi(ctx.ctx_t) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class _gr_fexpr_ctx(gr_scalar_ctx): - - @staticmethod - cdef inline _gr_fexpr_ctx _new(): - cdef _gr_fexpr_ctx ctx - ctx = _gr_fexpr_ctx.__new__(_gr_fexpr_ctx) - gr_ctx_init_fexpr(ctx.ctx_t) - ctx._init = True - return ctx - - -# The global contexts for use in cython code: -cdef _gr_fmpz_ctx gr_fmpz_ctx_c -cdef _gr_fmpq_ctx gr_fmpq_ctx_c -cdef _gr_fmpzi_ctx gr_fmpzi_ctx_c -cdef _gr_fexpr_ctx gr_fexpr_ctx_c - - -@cython.no_gc -cdef class gr_nmod_ctx(gr_scalar_ctx): - cdef ulong n - cdef bint is_field - - @staticmethod - cdef inline gr_nmod_ctx _new(ulong n): - cdef gr_nmod_ctx ctx - cdef bint is_prime = n_is_prime(n) - ctx = gr_nmod_ctx.__new__(gr_nmod_ctx) - ctx.n = n - ctx.is_field = is_prime - gr_ctx_init_nmod(ctx.ctx_t, n) - ctx._init = True - # if is_prime: - # gr_ctx_set_is_field(ctx.ctx_t, T_TRUE) - # else: - # gr_ctx_set_is_field(ctx.ctx_t, T_FALSE) - return ctx - - -@cython.no_gc -cdef class gr_fmpz_mod_ctx(gr_scalar_ctx): - cdef fmpz_t n - cdef bint is_field - - @staticmethod - cdef inline gr_fmpz_mod_ctx _new(fmpz n): - cdef gr_fmpz_mod_ctx ctx - cdef bint is_prime = n.is_prime() - ctx = gr_fmpz_mod_ctx.__new__(gr_fmpz_mod_ctx) - ctx.is_field = is_prime - fmpz_init_set(ctx.n, n.val) - gr_ctx_init_fmpz_mod(ctx.ctx_t, ctx.n) - ctx._init = True - # if is_prime: - # gr_ctx_set_is_field(ctx.ctx_t, T_TRUE) - # else: - # gr_ctx_set_is_field(ctx.ctx_t, T_FALSE) - return ctx - - -@cython.no_gc -cdef class gr_fq_ctx(gr_scalar_ctx): - cdef fmpz_t p - cdef slong d - - @staticmethod - cdef inline gr_fq_ctx _new(fmpz p, slong d, char* name): - cdef gr_fq_ctx ctx - ctx = gr_fq_ctx.__new__(gr_fq_ctx) - ctx.d = d - fmpz_init_set(ctx.p, p.val) - gr_ctx_init_fq(ctx.ctx_t, ctx.p, d, name) - ctx._init = True - # XXX: free name_c? - return ctx - - -@cython.no_gc -cdef class gr_fq_nmod_ctx(gr_scalar_ctx): - cdef ulong p - cdef slong d - - @staticmethod - cdef inline gr_fq_nmod_ctx _new(ulong p, slong d, char* name): - cdef gr_fq_nmod_ctx ctx - ctx = gr_fq_nmod_ctx.__new__(gr_fq_nmod_ctx) - ctx.p = p - ctx.d = d - gr_ctx_init_fq_nmod(ctx.ctx_t, p, d, name) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class gr_fq_zech_ctx(gr_scalar_ctx): - cdef ulong p - cdef slong d - - @staticmethod - cdef inline gr_fq_zech_ctx _new(ulong p, slong d, char* name): - cdef gr_fq_zech_ctx ctx - ctx = gr_fq_zech_ctx.__new__(gr_fq_zech_ctx) - ctx.p = p - ctx.d = d - gr_ctx_init_fq_zech(ctx.ctx_t, p, d, name) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class gr_nf_ctx(gr_scalar_ctx): - cdef fmpq_poly_t poly - - @staticmethod - cdef inline gr_nf_ctx _new(fmpq_poly poly): - cdef gr_nf_ctx ctx - ctx = gr_nf_ctx.__new__(gr_nf_ctx) - fmpq_poly_init(ctx.poly) - fmpq_poly_set(ctx.poly, poly.val) - gr_ctx_init_nf(ctx.ctx_t, ctx.poly) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class gr_nf_fmpz_poly_ctx(gr_scalar_ctx): - cdef fmpz_poly_t poly - - @staticmethod - cdef inline gr_nf_fmpz_poly_ctx _new(fmpz_poly poly): - cdef gr_nf_fmpz_poly_ctx ctx - ctx = gr_nf_fmpz_poly_ctx.__new__(gr_nf_fmpz_poly_ctx) - fmpz_poly_init(ctx.poly) - fmpz_poly_set(ctx.poly, poly.val) - gr_ctx_init_nf_fmpz_poly(ctx.ctx_t, ctx.poly) - ctx._init = True - return ctx - - -@cython.no_gc -cdef class gr_real_qqbar_ctx(gr_scalar_ctx): - cdef slong deg_limit - cdef slong bits_limit - - @staticmethod - cdef inline gr_real_qqbar_ctx _new(slong deg_limit, slong bits_limit): - cdef gr_real_qqbar_ctx ctx - ctx = gr_real_qqbar_ctx.__new__(gr_real_qqbar_ctx) - gr_ctx_init_real_qqbar(ctx.ctx_t) - ctx._init = True - ctx.deg_limit = deg_limit - ctx.bits_limit = bits_limit - if deg_limit != -1 or bits_limit != -1: - # Maybe add setters for these? - # XXX: Not available in FLINT 3.0.1 - # _gr_ctx_qqbar_set_limits(ctx.ctx_t, deg_limit, bits_limit) - pass - return ctx - - -@cython.no_gc -cdef class gr_complex_qqbar_ctx(gr_scalar_ctx): - cdef slong deg_limit - cdef slong bits_limit - - @staticmethod - cdef inline gr_complex_qqbar_ctx _new(slong deg_limit, slong bits_limit): - cdef gr_complex_qqbar_ctx ctx - ctx = gr_complex_qqbar_ctx.__new__(gr_complex_qqbar_ctx) - gr_ctx_init_complex_qqbar(ctx.ctx_t) - ctx._init = True - ctx.deg_limit = deg_limit - ctx.bits_limit = bits_limit - if deg_limit != -1 or bits_limit != -1: - # Maybe add setters for these? - # XXX: Not available in FLINT 3.0.1 - # _gr_ctx_qqbar_set_limits(ctx.ctx_t, deg_limit, bits_limit) - pass - return ctx - - -@cython.no_gc -cdef class gr_real_ca_ctx(gr_scalar_ctx): - cdef dict options - - @staticmethod - cdef inline gr_real_ca_ctx _new(dict options): - cdef gr_real_ca_ctx ctx - if options: - raise NotImplementedError("Options not implemented yet") - ctx = gr_real_ca_ctx.__new__(gr_real_ca_ctx) - gr_ctx_init_real_ca(ctx.ctx_t) - ctx._init = True - ctx.options = options.copy() - return ctx - - -@cython.no_gc -cdef class gr_complex_ca_ctx(gr_scalar_ctx): - cdef dict options - - @staticmethod - cdef inline gr_complex_ca_ctx _new(dict options): - cdef gr_complex_ca_ctx ctx - if options: - raise NotImplementedError("Options not implemented yet") - ctx = gr_complex_ca_ctx.__new__(gr_complex_ca_ctx) - gr_ctx_init_complex_ca(ctx.ctx_t) - ctx._init = True - ctx.options = options.copy() - return ctx - - -@cython.no_gc -cdef class gr_real_algebraic_ca_ctx(gr_scalar_ctx): - cdef dict options - - @staticmethod - cdef inline gr_real_algebraic_ca_ctx _new(dict options): - cdef gr_real_algebraic_ca_ctx ctx - if options: - raise NotImplementedError("Options not implemented yet") - ctx = gr_real_algebraic_ca_ctx.__new__(gr_real_algebraic_ca_ctx) - gr_ctx_init_real_algebraic_ca(ctx.ctx_t) - ctx._init = True - ctx.options = options.copy() - return ctx - - -@cython.no_gc -cdef class gr_complex_algebraic_ca_ctx(gr_scalar_ctx): - cdef dict options - - @staticmethod - cdef inline gr_complex_algebraic_ca_ctx _new(dict options): - cdef gr_complex_algebraic_ca_ctx ctx - if options: - raise NotImplementedError("Options not implemented yet") - ctx = gr_complex_algebraic_ca_ctx.__new__(gr_complex_algebraic_ca_ctx) - gr_ctx_init_complex_algebraic_ca(ctx.ctx_t) - ctx._init = True - ctx.options = options.copy() - return ctx - - -@cython.no_gc -cdef class gr_complex_extended_ca_ctx(gr_scalar_ctx): - cdef dict options - - @staticmethod - cdef inline gr_complex_extended_ca_ctx _new(dict options): - cdef gr_complex_extended_ca_ctx ctx - if options: - raise NotImplementedError("Options not implemented yet") - ctx = gr_complex_extended_ca_ctx.__new__(gr_complex_extended_ca_ctx) - gr_ctx_init_complex_extended_ca(ctx.ctx_t) - ctx._init = True - ctx.options = options.copy() - return ctx - - -@cython.no_gc -cdef class gr_real_float_arf_ctx(gr_scalar_ctx): - cdef slong prec - - @staticmethod - cdef inline gr_real_float_arf_ctx _new(slong prec): - cdef gr_real_float_arf_ctx ctx - ctx = gr_real_float_arf_ctx.__new__(gr_real_float_arf_ctx) - gr_ctx_init_real_float_arf(ctx.ctx_t, prec) - ctx._init = True - ctx.prec = prec - return ctx - - -@cython.no_gc -cdef class gr_complex_float_acf_ctx(gr_scalar_ctx): - cdef slong prec - - @staticmethod - cdef inline gr_complex_float_acf_ctx _new(slong prec): - cdef gr_complex_float_acf_ctx ctx - ctx = gr_complex_float_acf_ctx.__new__(gr_complex_float_acf_ctx) - gr_ctx_init_complex_float_acf(ctx.ctx_t, prec) - ctx._init = True - ctx.prec = prec - return ctx - - -@cython.no_gc -cdef class gr_real_arb_ctx(gr_scalar_ctx): - cdef slong prec - - @staticmethod - cdef inline gr_real_arb_ctx _new(slong prec): - cdef gr_real_arb_ctx ctx - ctx = gr_real_arb_ctx.__new__(gr_real_arb_ctx) - gr_ctx_init_real_arb(ctx.ctx_t, prec) - ctx._init = True - ctx.prec = prec - return ctx - - -@cython.no_gc -cdef class gr_complex_acb_ctx(gr_scalar_ctx): - cdef slong prec - - @staticmethod - cdef inline gr_complex_acb_ctx _new(slong prec): - cdef gr_complex_acb_ctx ctx - ctx = gr_complex_acb_ctx.__new__(gr_complex_acb_ctx) - gr_ctx_init_complex_acb(ctx.ctx_t, prec) - ctx._init = True - ctx.prec = prec - return ctx - - -# @cython.no_gc -# cdef class _gr_fmpz_poly_ctx(gr_poly_ctx): -# -# @staticmethod -# cdef _gr_fmpz_poly_ctx _new() - - -# @cython.no_gc -# cdef class _gr_fmpq_poly_ctx(gr_poly_ctx): -# -# @staticmethod -# cdef _gr_fmpq_poly_ctx _new() - - -# @cython.no_gc -# cdef class _gr_gr_poly_ctx(gr_poly_ctx): -# -# @staticmethod -# cdef _gr_gr_poly_ctx _new() - - -@cython.no_gc -cdef class gr_gr_poly_ctx(gr_poly_ctx): - cdef gr_ctx base_ctx - - @staticmethod - cdef inline gr_gr_poly_ctx _new(gr_ctx base_ctx): - cdef gr_gr_poly_ctx ctx - ctx = gr_gr_poly_ctx.__new__(gr_gr_poly_ctx) - gr_ctx_init_gr_poly(ctx.ctx_t, base_ctx.ctx_t) - ctx._init = True - ctx.base_ctx = base_ctx - return ctx - - -@cython.no_gc -cdef class gr_gr_mpoly_ctx(gr_mpoly_ctx): - cdef gr_ctx base_ctx - cdef ordering_t _order - cdef tuple _names - cdef slong _nvars - - @staticmethod - cdef inline gr_gr_mpoly_ctx _new(gr_ctx base_ctx, tuple names, order): - cdef gr_gr_mpoly_ctx ctx - cdef ordering_t ord_c - cdef slong nvars - cdef const char **names_c - cdef int status - - nvars = len(names) - names_b = [name.encode('utf-8') for name in names] - - ord_c = ordering_py_to_c(order) - ctx = gr_gr_mpoly_ctx.__new__(gr_gr_mpoly_ctx) - gr_ctx_init_gr_mpoly(ctx.ctx_t, base_ctx.ctx_t, nvars, ord_c) - ctx._init = True - ctx.base_ctx = base_ctx - ctx._order = ord_c - ctx._nvars = nvars - ctx._names = names - - names_c = libc.stdlib.malloc(nvars * sizeof(const char *)) - if names_c == NULL: - raise MemoryError("Failed to allocate memory for generator names") - try: - for i in range(nvars): - names_c[i] = names_b[i] - status = gr_ctx_set_gen_names(ctx.ctx_t, names_c) - finally: - libc.stdlib.free(names_c) - if status != GR_SUCCESS: - raise MemoryError("Failed to set generator names") - - return ctx - - -# @cython.no_gc -# cdef class gr_fmpz_mpoly_q_ctx(gr_mpoly_ctx): -# cdef ordering_t _order -# cdef slong _nvars -# -# @staticmethod -# cdef inline gr_fmpz_mpoly_q_ctx _new(slong nvars, order): -# cdef gr_fmpz_mpoly_q_ctx ctx -# cdef ordering_t ord_c -# ord_c = ordering_py_to_c(order) -# ctx = gr_fmpz_mpoly_q_ctx.__new__(gr_fmpz_mpoly_q_ctx) -# gr_ctx_init_fmpz_mpoly_q(ctx.ctx_t, nvars, ord_c) -# ctx._init = True -# ctx._order = ord_c -# ctx._nvars = nvars -# return ctx - - -# @cython.no_gc -# cdef class gr_series_mod_gr_poly_ctx(gr_ctx): -# cdef gr_ctx base_ctx -# cdef slong _n -# -# @staticmethod -# cdef inline gr_series_mod_gr_poly_ctx _new(gr_ctx base_ctx, slong n): -# cdef gr_series_mod_gr_poly_ctx ctx -# ctx = gr_series_mod_gr_poly_ctx.__new__(gr_series_mod_gr_poly_ctx) -# gr_ctx_init_series_mod_gr_poly(ctx.ctx_t, base_ctx.ctx_t, n) -# ctx._init = True -# ctx.base_ctx = base_ctx -# ctx._n = n -# return ctx - - -@cython.no_gc -cdef class gr_series_ctx(gr_ctx): - cdef gr_ctx base_ctx - cdef slong _prec - - @staticmethod - cdef inline gr_series_ctx _new(gr_ctx base_ctx, slong prec): - cdef gr_series_ctx ctx - ctx = gr_series_ctx.__new__(gr_series_ctx) - gr_ctx_init_gr_series(ctx.ctx_t, base_ctx.ctx_t, prec) - ctx._init = True - ctx.base_ctx = base_ctx - ctx._prec = prec - return ctx - - -@cython.no_gc -cdef class gr(flint_scalar): - cdef gr_ptr pval - cdef public gr_ctx ctx - cdef bint _init - - @cython.final - cdef inline _error(self, int err, str msg): - return self.ctx._error(err, msg) - - @cython.final - cdef inline truth_t _equal(self, other: gr): - return gr_equal(self.pval, other.pval, self.ctx.ctx_t) - - @cython.final - cdef inline truth_t _is_zero(self): - return gr_is_zero(self.pval, self.ctx.ctx_t) - - @cython.final - cdef inline truth_t _is_one(self): - return gr_is_one(self.pval, self.ctx.ctx_t) - - @cython.final - cdef inline truth_t _is_neg_one(self): - return gr_is_neg_one(self.pval, self.ctx.ctx_t) - - @cython.final - cdef inline gr _neg(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_neg(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to negate gr object") - return res - - @cython.final - cdef inline gr _add(self, other: gr): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_add(res.pval, self.pval, other.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to add gr objects") - return res - - @cython.final - cdef inline gr _add_si(self, other: slong): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_add_si(res.pval, self.pval, other, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to add gr object and int") - return res - - @cython.final - cdef inline gr _sub(self, other: gr): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_sub(res.pval, self.pval, other.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to subtract gr objects") - return res - - @cython.final - cdef inline gr _sub_si(self, other: int): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_sub_si(res.pval, self.pval, other, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to subtract gr object and int") - return res - - @cython.final - cdef inline gr _mul(self, other: gr): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_mul(res.pval, self.pval, other.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to multiply gr objects") - return res - - @cython.final - cdef inline gr _mul_si(self, other: slong): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_mul_si(res.pval, self.pval, other, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to multiply gr object and int") - return res - - @cython.final - cdef inline gr _inv(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_inv(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to invert gr object") - return res - - @cython.final - cdef inline gr _div(self, other: gr): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_div(res.pval, self.pval, other.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to divide gr objects") - return res - - @cython.final - cdef inline gr _div_si(self, other: slong): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_div_si(res.pval, self.pval, other, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to divide gr object and int") - return res - - @cython.final - cdef inline gr _pow_si(self, other: slong): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_pow_si(res.pval, self.pval, other, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to raise gr object to an integer power") - return res - - @cython.final - cdef inline truth_t _is_square(self): - return gr_is_square(self.pval, self.ctx.ctx_t) - - @cython.final - cdef inline gr _sqrt(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_sqrt(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute square root of gr object") - return res - - @cython.final - cdef inline gr _rsqrt(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_rsqrt(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute reciprocal square root of gr object") - return res - - @cython.final - cdef inline gr _gcd(self, other: gr): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_gcd(res.pval, self.pval, other.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute gcd of gr objects") - return res - - @cython.final - cdef inline gr _lcm(self, other: gr): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_lcm(res.pval, self.pval, other.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute lcm of gr objects") - return res - - cdef inline _factor(self): - cdef int err, i - cdef slong length, exp_s - cdef gr c, f - cdef gr_ptr fac_i, exp_i - cdef gr_vec_t factors, exponents - cdef int flags = 0 # XXX: What is flags? - c = self.ctx.new_gr() - gr_vec_init(factors, 0, self.ctx.ctx_t) - gr_vec_init(exponents, 0, gr_fmpz_ctx_c.ctx_t) - err = gr_factor(c.pval, factors, exponents, self.pval, flags, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to factor gr object") - length = gr_vec_length(factors, self.ctx.ctx_t) - py_factors = [None] * length - for 0 <= i < length: - f = self.ctx.new_gr() - fac_i = gr_vec_entry_ptr(factors, i, self.ctx.ctx_t) - err = gr_set(f.pval, fac_i, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to copy factor.") - exp_i = gr_vec_entry_ptr(exponents, i, gr_fmpz_ctx_c.ctx_t) - err = gr_get_si(&exp_s, exp_i, gr_fmpz_ctx_c.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to get integer value of exponent.") - exp = exp_s - py_factors[i] = (f, exp) - gr_vec_clear(factors, self.ctx.ctx_t) - gr_vec_clear(exponents, gr_fmpz_ctx_c.ctx_t) - return c, py_factors - - cdef inline gr _numerator(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_numerator(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute numerator of gr object") - return res - - cdef inline gr _denominator(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_denominator(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute denominator of gr object") - return res - - cdef inline gr _floor(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_floor(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute floor of gr object") - return res - - cdef inline gr _ceil(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_ceil(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute ceil of gr object") - return res - - cdef inline gr _trunc(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_trunc(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute trunc of gr object") - return res - - cdef inline gr _nint(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_nint(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute nint of gr object") - return res - - cdef inline gr _abs(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_abs(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute absolute value of gr object") - return res - - cdef inline gr _conj(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_conj(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute conjugate of gr object") - return res - - cdef inline gr _re(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_re(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute real part of gr object") - return res - - cdef inline gr _im(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_im(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute imaginary part of gr object") - return res - - cdef inline gr _sgn(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_sgn(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute sign of gr object") - return res - - cdef inline gr _csgn(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_csgn(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute complex sign of gr object") - return res - - cdef inline gr _arg(self): - cdef int err - cdef gr res = self.ctx.new_gr() - err = gr_arg(res.pval, self.pval, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self._error(err, "Failed to compute argument of gr object") - return res - - # cdef inline truth_t _le(self, other: gr): - # return gr_le(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _lt(self, other: gr): - # return gr_lt(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _ge(self, other: gr): - # return gr_ge(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _gt(self, other: gr): - # return gr_gt(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _abs_le(self, other: gr): - # return gr_abs_le(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _abs_lt(self, other: gr): - # return gr_abs_lt(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _abs_ge(self, other: gr): - # return gr_abs_ge(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline truth_t _abs_gt(self, other: gr): - # return gr_abs_gt(self.pval, other.pval, self.ctx.ctx_t) - - # cdef inline gr _min(self, other: gr): - # cdef int err - # cdef gr res = self.ctx.new_gr() - # err = gr_min(res.pval, self.pval, other.pval, self.ctx.ctx_t) - # if err != GR_SUCCESS: - # raise self._error(err, "Failed to compute minimum of gr objects") - # return res - - # cdef inline gr _max(self, other: gr): - # cdef int err - # cdef gr res = self.ctx.new_gr() - # err = gr_max(res.pval, self.pval, other.pval, self.ctx.ctx_t) - # if err != GR_SUCCESS: - # raise self._error(err, "Failed to compute maximum of gr objects") - # return res diff --git a/src/flint/types/_gr.pyx b/src/flint/types/_gr.pyx deleted file mode 100644 index a555f367..00000000 --- a/src/flint/types/_gr.pyx +++ /dev/null @@ -1,2089 +0,0 @@ -cimport cython - -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.gr cimport GR_SUCCESS -from flint.flintlib.functions.gr cimport ( - gr_ctx_clear, - gr_heap_clear, - - gr_set_si, -) -from flint.flintlib.functions.gr_domains cimport ( - gr_ctx_is_finite, - gr_ctx_is_multiplicative_group, - gr_ctx_is_ring, - gr_ctx_is_commutative_ring, - gr_ctx_is_integral_domain, - gr_ctx_is_unique_factorization_domain, - gr_ctx_is_field, - gr_ctx_is_algebraically_closed, - gr_ctx_is_finite_characteristic, - gr_ctx_is_ordered_ring, - # gr_ctx_is_zero_ring, - gr_ctx_is_exact, - gr_ctx_is_canonical, - gr_ctx_has_real_prec, - gr_ctx_set_real_prec, - gr_ctx_get_real_prec, -) - -from flint.flint_base.flint_base cimport ordering_c_to_py -from flint.flint_base.flint_base import Ordering - - -@cython.no_gc -cdef class gr_ctx(flint_ctx): - """Base class for all gr contexts. - - This class should not be instantiated directly. Instead, use one of the - derived classes, e.g. gr_nmod_ctx or gr_fmpz_ctx. - """ - def __init__(self, *args, **kwargs): - raise TypeError("Cannot create gr_ctx object directly." - " Use e.g. gr_nmod_ctx.new(n) instead.") - - def new(self): - """Create a context of a given type. - - This method should be called on a derived class: - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> ctx10 = gr_real_float_arf_ctx.new(10) - >>> ctx10 - gr_real_float_arf_ctx(10) - >>> ctx10.real_prec - 10 - >>> ctx10(2).sqrt() # 10 bits - 1.414 - >>> ctx100 = gr_real_float_arf_ctx.new(100) - >>> ctx100(2).sqrt() # 100 bits - 1.414213562373095048801688724209 - """ - raise NotImplementedError("Cannot create gr_ctx object directly." - " Use e.g. gr_nmod_ctx.new(n) instead.") - - def __dealloc__(self): - if self._init: - self._init = False - gr_ctx_clear(self.ctx_t) - - @property - def is_finite(self) -> bool | None: - """True if the domain is finite (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_fmpz_ctx, gr_nmod_ctx - >>> R1 = gr_fmpz_ctx - >>> R2 = gr_nmod_ctx.new(5) - >>> R1.is_finite, R2.is_finite - (False, True) - """ - return truth_to_py(gr_ctx_is_finite(self.ctx_t)) - - @property - def is_multiplicative_group(self) -> bool | None: - """True if the domain is a multiplicative group (can be ``None`` if unknown).""" - return truth_to_py(gr_ctx_is_multiplicative_group(self.ctx_t)) - - @property - def is_ring(self) -> bool | None: - """True if the domain is a ring (can be ``None`` if unknown).""" - return truth_to_py(gr_ctx_is_ring(self.ctx_t)) - - @property - def is_commutative_ring(self) -> bool | None: - """True if the domain is a commutative ring (can be ``None`` if unknown).""" - return truth_to_py(gr_ctx_is_commutative_ring(self.ctx_t)) - - @property - def is_integral_domain(self) -> bool | None: - """True if the domain is an integral domain (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_nmod_ctx - >>> R1 = gr_nmod_ctx.new(5) - >>> R2 = gr_nmod_ctx.new(6) - >>> R1.is_integral_domain, R2.is_integral_domain - (True, False) - """ - return truth_to_py(gr_ctx_is_integral_domain(self.ctx_t)) - - @property - def is_unique_factorization_domain(self) -> bool | None: - """True if the domain is a unique factorization domain (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_fmpz_ctx - >>> R1 = gr_fmpz_ctx - >>> R1.is_unique_factorization_domain - True - """ - return truth_to_py(gr_ctx_is_unique_factorization_domain(self.ctx_t)) - - @property - def is_field(self) -> bool | None: - """True if the domain is a field (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_fmpz_ctx, gr_fmpq_ctx - >>> R1 = gr_fmpz_ctx - >>> R2 = gr_fmpq_ctx - >>> R1.is_field, R2.is_field - (False, True) - """ - return truth_to_py(gr_ctx_is_field(self.ctx_t)) - - @property - def is_algebraically_closed(self) -> bool | None: - """True if the domain is algebraically closed (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_complex_qqbar_ctx, gr_real_qqbar_ctx - >>> R1 = gr_complex_qqbar_ctx.new() - >>> R2 = gr_real_qqbar_ctx.new() - >>> R1.is_algebraically_closed, R2.is_algebraically_closed - (True, False) - """ - return truth_to_py(gr_ctx_is_algebraically_closed(self.ctx_t)) - - @property - def is_finite_characteristic(self) -> bool | None: - """True if the domain has finite characteristic (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_nmod_ctx, gr_fmpz_ctx - >>> R1 = gr_nmod_ctx.new(5) - >>> R2 = gr_fmpz_ctx - >>> R1.is_finite_characteristic, R2.is_finite_characteristic - (True, False) - """ - return truth_to_py(gr_ctx_is_finite_characteristic(self.ctx_t)) - - @property - def is_ordered_ring(self) -> bool | None: - """True if the domain is an ordered ring (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_fmpz_ctx, gr_nmod_ctx - >>> R1 = gr_fmpz_ctx - >>> R2 = gr_nmod_ctx.new(5) - >>> R1.is_ordered_ring, R2.is_ordered_ring - (True, None) - """ - return truth_to_py(gr_ctx_is_ordered_ring(self.ctx_t)) - - # @property - # def is_zero_ring(self) -> bool | None: - # """True if the domain is a zero ring (can be ``None`` if unknown).""" - # return truth_to_py(gr_ctx_is_zero_ring(self.ctx_t)) - - @property - def is_exact(self) -> bool | None: - """True if the domain is exact (can be ``None`` if unknown). - - >>> from flint.types._gr import gr_fmpz_ctx, gr_real_float_arf_ctx - >>> R1 = gr_fmpz_ctx - >>> R2 = gr_real_float_arf_ctx.new(10) - >>> R1.is_exact, R2.is_exact - (True, False) - """ - return truth_to_py(gr_ctx_is_exact(self.ctx_t)) - - @property - def is_canonical(self) -> bool | None: - """True if elements of the domain are always canonical.""" - return truth_to_py(gr_ctx_is_canonical(self.ctx_t)) - - @property - def has_real_prec(self) -> bool | None: - """True if the domain has real precision (can be ``None`` if unknown). - - See also :attr:`real_prec`. - """ - return truth_to_py(gr_ctx_has_real_prec(self.ctx_t)) - - @property - def real_prec(self) -> int: - """Real precision of the domain. - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> ctx = gr_real_float_arf_ctx.new(10) - >>> ctx.real_prec - 10 - >>> ctx.real_prec = 20 - >>> ctx.real_prec - 20 - """ - cdef slong prec - if gr_ctx_has_real_prec(self.ctx_t) != T_TRUE: - raise ValueError("Real precision is not available") - if gr_ctx_get_real_prec(&prec, self.ctx_t) != GR_SUCCESS: - raise ValueError("Failed to get real precision") - return prec - - @real_prec.setter - def real_prec(self, prec: slong) -> None: - if gr_ctx_has_real_prec(self.ctx_t) != T_TRUE: - raise ValueError("Real precision is not available") - if gr_ctx_set_real_prec(self.ctx_t, prec) != GR_SUCCESS: - raise ValueError("Failed to set real precision") - - def __call__(self, arg) -> gr: - """Create a new element of the domain. - - >>> from flint.types._gr import gr_fmpz_ctx - >>> ctx = gr_fmpz_ctx - >>> ctx(2) - 2 - >>> ctx(18446744073709551615) - 18446744073709551615 - """ - if isinstance(arg, gr): - if arg.ctx == self: - return arg - return self.from_other(arg) - if type(arg) is int: - try: - return self.from_si(arg) - except OverflowError: - pass - if type(arg) is float: - return self.from_d(arg) - # TODO: fmpz & fmpq ? - try: - return self.from_str(str(arg)) - except AssertionError: - return self.from_si(int(arg)) - - def zero(self) -> gr: - """Return the zero element of the domain. - - >>> from flint.types._gr import gr_fmpz_ctx - >>> ctx = gr_fmpz_ctx - >>> ctx.zero() - 0 - """ - return self._zero() - - def one(self) -> gr: - """Return the one element of the domain. - - >>> from flint.types._gr import gr_fmpz_ctx - >>> ctx = gr_fmpz_ctx - >>> ctx.one() - 1 - """ - return self._one() - - def i(self) -> gr: - """Return the imaginary unit of the domain (if available). - - >>> from flint.types._gr import gr_fmpzi_ctx - >>> ctx = gr_fmpzi_ctx - >>> ctx.i() - I - """ - return self._i() - - def pos_inf(self) -> gr: - """Return the positive infinity element of the domain (if available). - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> ctx = gr_real_float_arf_ctx.new(10) - >>> ctx.pos_inf() - +inf - """ - return self._pos_inf() - - def neg_inf(self) -> gr: - """Return the negative infinity element of the domain (if available). - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> ctx = gr_real_float_arf_ctx.new(10) - >>> ctx.neg_inf() - -inf - """ - return self._neg_inf() - - def uinf(self) -> gr: - """Return the unsigned infinity element of the domain (if available). - - >>> from flint.types._gr import gr_complex_extended_ca_ctx - >>> ctx = gr_complex_extended_ca_ctx.new() - >>> ctx.uinf() - UnsignedInfinity - """ - return self._uinf() - - def undefined(self) -> gr: - """Return the undefined element of the domain (if available). - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> ctx = gr_real_float_arf_ctx.new(10) - >>> ctx.undefined() - nan - """ - return self._undefined() - - def unknown(self) -> gr: - """Return the unknown element of the domain (if available). - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> ctx = gr_real_float_arf_ctx.new(10) - >>> ctx.unknown() - nan - """ - return self._unknown() - - def gen(self) -> gr: - """Return the generator of the domain (if available). - - >>> from flint.types._gr import gr_fmpzi_ctx, gr_fq_ctx - >>> ctx = gr_fmpzi_ctx - >>> ctx.gen() - I - >>> ctx = gr_fq_ctx.new(5, 2) - >>> ctx.gen() - a - """ - return self._gen() - - def gens(self) -> list[gr]: - """Return the top-level generators of the domain - - # XXX: Does not work with FLINT < 3.1 - - # >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx - # >>> ctx = gr_gr_mpoly_ctx.new(gr_fmpzi_ctx, ['x', 'y']) - # >>> ctx.gens() - # [x, y] - # >>> gr_fmpzi_ctx.gens() - # [I] - # >>> ctx.gens_recursive() - # [I, x, y] - """ - return self._gens() - - def is_zero(self, x) -> bool | None: - """ - Returns whether x is equal to the ring element 0. - - >>> from flint.types._gr import gr_real_arb_ctx - >>> ctx = gr_real_arb_ctx.new(10) - >>> ctx.is_zero(ctx(0)) - True - >>> ctx.is_zero(ctx(1)) - False - >>> ctx.is_zero(ctx("[0 +/- 0.1]")) - """ - return truth_to_py(self._is_zero(x)) - - def is_one(self, x) -> bool | None: - """ - Returns whether x is equal to the ring element 1. - - >>> from flint.types._gr import gr_real_arb_ctx - >>> ctx = gr_real_arb_ctx.new(10) - >>> ctx.is_one(ctx(0)) - False - >>> ctx.is_one(ctx(1)) - True - >>> ctx.is_one(ctx("[1 +/- 0.1]")) - """ - return truth_to_py(self._is_one(x)) - - def is_neg_one(self, x) -> bool | None: - """ - Returns whether x is equal to the ring element -1. - - >>> from flint.types._gr import gr_real_arb_ctx - >>> ctx = gr_real_arb_ctx.new(10) - >>> ctx.is_neg_one(ctx(1)) - False - >>> ctx.is_neg_one(ctx(-1)) - True - >>> ctx.is_neg_one(ctx("[-1 +/- 0.1]")) - """ - return truth_to_py(self._is_neg_one(x)) - - def equal(self, x, y) -> bool | None: - """ - Returns whether the elements `x` and `y` are equal. - """ - return self._equal(self(x), self(y)) - - # def is_integer(self, x): - # """ - # Returns whether `x` represents an integer. - # """ - # return self._is_integer(self(x)) - # - # def is_rational(self, x): - # """ - # Returns whether x represents a rational number. - # """ - # return self._is_rational(self(x)) - - def neg(self, x) -> gr: - """ - Returns `-x`. - - >>> from flint.types._gr import gr_complex_acb_ctx, gr_real_arb_ctx - >>> arb = gr_real_arb_ctx.new(53); acb = gr_complex_acb_ctx.new(106) - >>> c = acb("2 + I").sqrt(); c - ([1.4553466902253548081226618397097 +/- 3.48e-32] + [0.3435607497225124641385657439146 +/- 5.23e-32]*I) - >>> acb.neg(c) - ([-1.4553466902253548081226618397097 +/- 3.48e-32] + [-0.3435607497225124641385657439146 +/- 5.23e-32]*I) - """ - return self._neg(self(x)) - - ### - # Arithmetic methods - - def add(self, x, y) -> gr: - """ - Returns `x + y` - - """ - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx == self: - return self._add(x, y) - if x.ctx == self: - return self._add_other(x, y) - if y.ctx == self: - return self._other_add(x, y) - - if isinstance(x, gr) and x.ctx == self and type(y) is int: - try: - return self._add_si(x, y) - except OverflowError: - pass - - # NOTE: By default, convert everything to the required - # context before performing the operation - return self._add(self(x), self(y)) - - def sub(self, x, y) -> gr: - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx == self: - return self._sub(x, y) - if x.ctx == self: - return self._sub_other(x, y) - if y.ctx == self: - return self._other_sub(x, y) - - if isinstance(x, gr) and x.ctx == self and type(y) is int: - try: - return self._sub_si(x, y) - except OverflowError: - pass - - # NOTE: By default, convert everything to the required - # context before performing the operation - return self._sub(self(x), self(y)) - - def mul(self, x, y) -> gr: - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx == self: - return self._mul(x, y) - if x.ctx == self: - return self._mul_other(x, y) - if y.ctx == self: - return self._other_mul(x, y) - - if isinstance(x, gr) and x.ctx == self and type(y) is int: - try: - return self._mul_si(x, y) - except OverflowError: - pass - - # NOTE: By default, convert everything to the required - # context before performing the operation - return self._mul(self(x), self(y)) - - ### - # Division - - def is_invertible(self, x) -> bool | None: - """ - Returns whether `x` has a multiplicative inverse in the present ring, i.e. whether `x` is a unit. - """ - return self._is_invertible(self(x)) - - def inv(self, x) -> gr: - """ - Returns the multiplicative inverse of `x` in the present ring, if such an element exists. - """ - return self._inv(self(x)) - - def div(self, x, y) -> gr: - """ - Returns the quotient `x/y` - """ - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx == self: - return self._div(x, y) - if x.ctx == self: - return self._div_other(x, y) - if y.ctx == self: - return self._other_div(x, y) - - if isinstance(x, gr) and x.ctx == self and type(y) is int: - try: - return self._div_si(x, y) - except OverflowError: - pass - - # NOTE: By default, convert everything to the required - # context before performing the operation - return self._div(self(x), self(y)) - - def divexact(self, x, y) -> gr: - """ - Returns the quotient `x/y`, assuming that the quotient is exact in the current context. - """ - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx == self: - return self._divexact(x, y) - if x.ctx == self: - return self._divexact_other(x, y) - if y.ctx == self: - return self._other_divexact(x, y) - - if isinstance(x, gr) and x.ctx == self and type(y) is int: - try: - return self._divexact_si(x, y) - except OverflowError: - pass - - # NOTE: By default, convert everything to the required - # context before performing the operation - return self._divexact(self(x), self(y)) - - def div_nonunique(self, x, y) -> gr: - """ - Returns an arbitrary solution `q` of the equation `x = qy`. - """ - return self._div_nonunique(self(x), self(y)) - - def divides(self, d, x) -> bool | None: - """ - Returns whether `d | x`; that is, whether there is an element `q` such that `x = qd`. - """ - return self._divides(self(d), self(x)) - - def euclidean_div(self, x, y) -> gr: - return self._euclidean_div(self(x), self(y)) - - def euclidean_rem(self, x, y) -> gr: - return self._euclidean_rem(self(x), self(y)) - - def euclidean_divrem(self, x, y) -> tuple[gr, gr]: - return self._euclidean_divrem(self(x), self(y)) - - ### - # Powering - - def pow(self, x, y) -> gr: - """ - Returns the power x^y, the interpretation of which depends on the ring when y ∉ ℤ - """ - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx == self: - return self._pow(x, y) - if x.ctx == self: - return self._pow_other(x, y) - if y.ctx == self: - return self._other_pow(x, y) - - if isinstance(x, gr) and x.ctx == self and type(y) is int: - try: - return self._pow_si(x, y) - except OverflowError: - pass - - # NOTE: By default, convert everything to the required - # context before performing the operation - return self._pow(self(x), self(y)) - - ### - # Square Roots - - def is_square(self, x) -> bool | None: - """ - Returns whether x is a perfect square in the context. - """ - return truth_to_py(self._is_square(self(x))) - - def sqrt(self, x) -> gr: - """ - Returns the square root of `x`. - """ - return self._sqrt(self(x)) - - def rsqrt(self, x) -> gr: - """ - Returns the reciprocal square root of `x`. - """ - return self._rsqrt(self(x)) - - ### - # Greatest Common Divisors - - def gcd(self, x, y) -> gr: - """ - Returns a greatest common divisor (GCD) of `x` and `y`. - Since the GCD is unique only up to multiplication by a unit, - an implementation-defined representative is chosen. - """ - return self._gcd(self(x), self(y)) - - def lcm(self, x, y) -> gr: - """ - Returns a least common multiple (LCM) of x and y. - Since the LCM is unique only up to multiplication by a unit, - an implementation-defined representative is chosen. - """ - return self._lcm(self(x), self(y)) - - ### - # Factorization - - def factor(self, x) -> tuple[gr, list[tuple[gr, int]]]: - """ - Given an element of the context, this returns a factorization ``(c, f, e)``: - ``x = c f₁^e₁ ··· fₙ^eₙ``, where ``fₖ`` will be irreducible or prime depending on the ring. - The prefactor c stores a unit, sign or coefficient. - Note that c is an element of the same ring as x. - """ - return self._factor(self(x)) - - ### - # Fractions - - def numerator(self, x) -> gr: - """ - Return a numerator p such that x = p / q. - For typical fraction fields, the denominator will be minimal and canonical. - However, some rings may return an arbitrary denominator as long as the numerator matches. - The default implementations simply returns p = x. - """ - return self._numerator(self(x)) - - def denominator(self, x) -> gr: - """ - Return a denominator q such that x = p / q. - For typical fraction fields, the denominator will be minimal and canonical. - However, some rings may return an arbitrary denominator as long as the numerator matches. - The default implementations simply returns q = 1. - """ - return self._denominator(self(x)) - - ### - # Integer and Complex parts - - def floor(self, x) -> gr: - return self._floor(self(x)) - - def ceil(self, x) -> gr: - return self._ceil(self(x)) - - def trunc(self, x) -> gr: - return self._trunc(self(x)) - - def nint(self, x) -> gr: - return self._nint(self(x)) - - def abs(self, x) -> gr: - return self._abs(self(x)) - - def conj(self, x) -> gr: - return self._conj(self(x)) - - def re(self, x) -> gr: - return self._re(self(x)) - - def im(self, x) -> gr: - return self._im(self(x)) - - def sgn(self, x) -> gr: - return self._sgn(self(x)) - - def csgn(self, x) -> gr: - return self._csgn(self(x)) - - def arg(self, x) -> gr: - return self._arg(self(x)) - - ### - # Ordering methods - - def cmp(self, x, y) -> int: - """ - Returns: - - -1 if x < y - - 0 if x = y - - 1 if x > y - """ - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx != self: - return self._cmp_other(x, y) - - if y.ctx == self and x.ctx != self: - return -self._cmp_other(y, x) - - if x.ctx == self == y.ctx: - return self._cmp(x, y) - - return self._cmp(self(x), self(y)) - - def cmpabs(self, x, y) -> int: - """ - Returns: - - -1 if `|x| < |y|` - - 0 if `|x| = |y|` - - 1 if `|x| > |y|` - """ - if isinstance(x, gr) and isinstance(y, gr): - if x.ctx == self and y.ctx != self: - return self._cmpabs_other(x, y) - - if y.ctx == self and x.ctx != self: - return -self._cmpabs_other(y, x) - - if x.ctx == self == y.ctx: - return self._cmpabs(x, y) - - return self._cmpabs(self(x), self(y)) - - def le(self, x, y) -> bool | None: - return truth_to_py(self._le(self(x), self(y))) - - def abs_le(self, x, y) -> bool | None: - return truth_to_py(self._abs_le(self(x), self(y))) - - def lt(self, x, y) -> bool | None: - return truth_to_py(self._lt(self(x), self(y))) - - def abs_lt(self, x, y) -> bool | None: - return truth_to_py(self._abs_lt(self(x), self(y))) - - def ge(self, x, y) -> bool | None: - return truth_to_py(self._ge(self(x), self(y))) - - def abs_ge(self, x, y) -> bool | None: - return truth_to_py(self._abs_ge(self(x), self(y))) - - def gt(self, x, y) -> bool | None: - return truth_to_py(self._gt(self(x), self(y))) - - def abs_gt(self, x, y) -> bool | None: - return truth_to_py(self._abs_gt(self(x), self(y))) - - def min(self, x, y) -> gr: - return self._min(self(x), self(y)) - - def max(self, x, y) -> gr: - return self._max(self(x), self(y)) - - ### - # Array-API wrappers - - def divide(self, x, y) -> gr: - return self.div(x, y) - - def greater(self, x, y): - return self.gt(x, y) - - def greater_equal(self, x, y): - return self.ge(x, y) - - def less(self, x, y): - return self.lt(x, y) - - def less_equal(self, x, y): - return self.le(x, y) - - def imag(self, x): - return self.im(x) - - def real(self, x): - return self.re(x) - - def maximum(self, x, y): - return self.max(x, y) - - def minimum(self, x, y): - return self.min(x, y) - - def multiply(self, x, y): - return self.mul(x, y) - - def negative(self, x): - return self.neg(x) - - def not_equal(self, x, y): - eq = self.equal(x, y) - if eq is None: - return None - return not eq - -cdef class gr_scalar_ctx(gr_ctx): - """Base class for all scalar contexts.""" - pass - - -cdef class gr_poly_ctx(gr_ctx): - """Base class for dense univariate polynomial contexts.""" - pass - - -cdef class gr_mpoly_ctx(gr_ctx): - """Base class for dense multivariate polynomial contexts.""" - pass - - -# cdef class gr_matrix_domain_ctx(gr_ctx): -# pass - - -# cdef class gr_matrix_space_ctx(gr_ctx): -# pass - - -# cdef class gr_matrix_ring_ctx(gr_ctx): -# pass - - -# Global contexts for Cython code -cdef _gr_fmpz_ctx gr_fmpz_ctx_c = _gr_fmpz_ctx._new() -cdef _gr_fmpq_ctx gr_fmpq_ctx_c = _gr_fmpq_ctx._new() -cdef _gr_fmpzi_ctx gr_fmpzi_ctx_c = _gr_fmpzi_ctx._new() -cdef _gr_fexpr_ctx gr_fexpr_ctx_c = _gr_fexpr_ctx._new() - -# Global contexts for Python code -gr_fmpz_ctx = gr_fmpz_ctx_c -gr_fmpq_ctx = gr_fmpq_ctx_c -gr_fmpzi_ctx = gr_fmpzi_ctx_c -gr_fexpr_ctx = gr_fexpr_ctx_c - - -@cython.no_gc -cdef class _gr_fmpz_ctx(gr_scalar_ctx): - r"""Context for arbitrary precision integers, `\mathbb{Z}`.""" - - @staticmethod - def new() -> _gr_fmpz_ctx: - """The global context for arbitrary precision integers. - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z - gr_fmpz_ctx - >>> Z(10) - 10 - >>> Z(10) + Z(20) - 30 - >>> Z(10) * Z(20) - 200 - >>> Z(10) / Z(20) - Traceback (most recent call last): - ... - AssertionError: Failed to divide gr objects - >>> Z(10).factor() - (1, [(2, 1), (5, 1)]) - >>> Z(9).sqrt() - 3 - """ - return gr_fmpz_ctx_c - - def __repr__(self): - return "gr_fmpz_ctx" - - -@cython.no_gc -cdef class _gr_fmpq_ctx(gr_scalar_ctx): - r"""Context for arbitrary precision rationals, `\mathbb{Q}`.""" - - @staticmethod - def new() -> _gr_fmpq_ctx: - """The global context for arbitrary precision rationals. - - >>> from flint.types._gr import gr_fmpq_ctx as Q - >>> Q - gr_fmpq_ctx - >>> Q(2) / 3 - 2/3 - """ - return gr_fmpq_ctx_c - - def __repr__(self): - return "gr_fmpq_ctx" - - -@cython.no_gc -cdef class _gr_fmpzi_ctx(gr_scalar_ctx): - r"""Context for Gaussian integers, `\mathbb{Z}[i]`. """ - - @staticmethod - def new() -> _gr_fmpzi_ctx: - """The global context for Gaussian integers. - - >>> from flint.types._gr import gr_fmpzi_ctx as ZI - >>> ZI - gr_fmpzi_ctx - >>> ZI.i() - I - >>> ZI.gen() - I - >>> I = ZI.i() - >>> (2 + 3*I) ** 2 - (-5+12*I) - """ - return gr_fmpzi_ctx_c - - def __repr__(self): - return "gr_fmpzi_ctx" - - -@cython.no_gc -cdef class _gr_fexpr_ctx(gr_scalar_ctx): - """Context for symbolic expressions. """ - - @staticmethod - def new() -> _gr_fexpr_ctx: - """The global context for symbolic expressions. - - >>> from flint.types._gr import gr_fexpr_ctx as EX - >>> EX - gr_fexpr_ctx - >>> (EX(1) + EX(2)) / 3 - Div(Add(1, 2), 3) - """ - return gr_fexpr_ctx_c - - def __repr__(self): - return "gr_fexpr_ctx" - - -@cython.no_gc -cdef class gr_nmod_ctx(gr_scalar_ctx): - r"""Context for integers modulo `n`, `\mathbb{Z}/n\mathbb{Z}`. - - The modulus `n` must be word-sized. Use :class:`gr_fmpz_mod_ctx` for - arbitrary precision modulus. - """ - @staticmethod - def new(ulong n) -> gr_nmod_ctx: - """Create a new context for integers modulo `n`. - - >>> from flint.types._gr import gr_nmod_ctx - >>> Z5 = gr_nmod_ctx.new(5) - >>> Z5 - gr_nmod_ctx(5) - >>> Z5(2) + Z5(3) - 0 - >>> Z5.modulus() - 5 - >>> Z5.is_prime - True - """ - return gr_nmod_ctx._new(n) - - @property - def is_prime(self) -> bool: - return self.is_field - - def modulus(self): - return self.n - - def __repr__(self): - return f"gr_nmod_ctx({self.n})" - - -@cython.no_gc -cdef class gr_fmpz_mod_ctx(gr_scalar_ctx): - r"""Context for integers modulo `n`, `\mathbb{Z}/n\mathbb{Z}`. - - The modulus `n` can be arbitrary precision. See also :class:`gr_nmod_ctx` - for word-sized modulus. - """ - - @staticmethod - def new(n) -> gr_fmpz_mod_ctx: - """Create a new context for integers modulo `n`. - - >>> from flint.types._gr import gr_fmpz_mod_ctx - >>> Z64 = gr_fmpz_mod_ctx.new(2**64 + 1) - >>> Z64 - gr_fmpz_mod_ctx(18446744073709551617) - >>> Z64(2)**64 + 2 - 1 - >>> Z64.is_prime - False - >>> Z64.modulus() - 18446744073709551617 - """ - n = fmpz(n) - return gr_fmpz_mod_ctx._new(n) - - @property - def is_prime(self) -> bool: - return self.is_field - - def modulus(self): - cdef fmpz n = fmpz.__new__(fmpz) - fmpz_init_set(n.val, self.n) - return n - - def __repr__(self): - return f"gr_fmpz_mod_ctx({self.modulus()})" - - -@cython.no_gc -cdef class gr_fq_ctx(gr_scalar_ctx): - r"""Context for finite fields, `\mathbb{F}_q` where `q = p^d`. - - The characteristic `p` must be a prime number and the degree `d` must be - positive. The characteristic `p` can be arbitrary precision. Use - :class:`gr_fq_nmod_ctx` for word-sized characteristic. For very small - characteristic, use :class:`gr_fq_zech_ctx`. - """ - - @staticmethod - def new(p, d, name=None) -> gr_fq_ctx: - """Create a new context for finite fields. - - >>> from flint.types._gr import gr_fq_ctx - >>> F9 = gr_fq_ctx.new(3, 2) - >>> F9 - gr_fq_ctx(3, 2) - >>> F9(2) + F9(3) - 2 - >>> F9.characteristic() - 3 - >>> F9.degree() - 2 - >>> F9.gen() - a - >>> a = F9.gen() - >>> (1 + a) ** 2 + a - a+2 - """ - cdef bytes name_b - cdef char *name_c - if name is not None: - name_b = name.encode('utf-8') - name_c = name_b - else: - name_c = NULL - p = fmpz(p) - return gr_fq_ctx._new(p, d, name_c) - - def characteristic(self): - cdef fmpz p = fmpz.__new__(fmpz) - fmpz_init_set(p.val, self.p) - return p - - def degree(self): - return self.d - - def __repr__(self): - return f"gr_fq_ctx({self.characteristic()}, {self.degree()})" - - -@cython.no_gc -cdef class gr_fq_nmod_ctx(gr_scalar_ctx): - r"""Context for finite fields, `\mathbb{F}_q` where `q = p^d`. - - The characteristic `p` must be a prime number and the degree `d` must be - positive. The characteristic `p` must be word-sized. Use :class:`gr_fq_ctx` - for arbitrary precision characteristic. For very small characteristic, use - :class:`gr_fq_zech_ctx`. - """ - - @staticmethod - def new(p, d, name=None) -> gr_fq_nmod_ctx: - """Create a new context for finite fields. - - # XXX: Does not work with FLINT < 3.1 - # >>> from flint.types._gr import gr_fq_nmod_ctx - # >>> F9 = gr_fq_nmod_ctx.new(3, 2) - # >>> F9 - # gr_fq_nmod_ctx(3, 2) - # >>> F9(2) + F9(3) - # 2 - # >>> F9.characteristic() - # 3 - # >>> F9.degree() - # 2 - # >>> F9.gen() - # a - # >>> a = F9.gen() - # >>> (1 + a) ** 2 + a - # a+2 - """ - cdef bytes name_b - cdef char *name_c - if name is not None: - name_b = name.encode('utf-8') - name_c = name_b - else: - name_c = NULL - return gr_fq_nmod_ctx._new(p, d, name_c) - - def characteristic(self): - return self.p - - def degree(self): - return self.d - - def __repr__(self): - return f"gr_fq_nmod_ctx({self.characteristic()}, {self.degree()})" - - -@cython.no_gc -cdef class gr_fq_zech_ctx(gr_scalar_ctx): - r"""Context for finite fields, `\mathbb{F}_q` where `q = p^d`. - - The characteristic `p` must be a prime number and the degree `d` must be - positive. The characteristic `p` must be small. Use :class:`gr_nmod_ctx` - for word-sized characteristic and :class:`gr_fq_ctx` for arbitrary - precision characteristic. - - .. warning:: - This type is possibly not working correctly. Use with caution. - """ - - @staticmethod - def new(p, d, name=None) -> gr_fq_zech_ctx: - """Create a new context for finite fields with small characteristic. - - # XXX: Does not work with FLINT < 3.1 - # >>> from flint.types._gr import gr_fq_zech_ctx - # >>> F9 = gr_fq_zech_ctx.new(3, 2) - # >>> F9 - # gr_fq_zech_ctx(3, 2) - # >>> F9(2) + F9(3) # XXX: Is this correct? - # a^4 - # >>> F9.characteristic() - # 3 - # >>> F9.degree() - # 2 - # >>> F9.gen() - # a^1 - # >>> a = F9.gen() - # >>> (1 + a) ** 2 + a # doctest: +SKIP - # a+2 - """ - cdef bytes name_b - cdef char *name_c - if name is not None: - name_b = name.encode('utf-8') - name_c = name_b - else: - name_c = NULL - return gr_fq_zech_ctx._new(p, d, name_c) - - def characteristic(self): - return self.p - - def degree(self): - return self.d - - def __repr__(self): - return f"gr_fq_zech_ctx({self.characteristic()}, {self.degree()})" - - -@cython.no_gc -cdef class gr_nf_ctx(gr_scalar_ctx): - r"""Context for number fields, `\mathbb{Q}(\alpha)`. - - The number field is defined by a minimal polynomial `f(x)` in - `\mathbb{Q}[x]` and represents the field `\mathbb{Q}(\alpha)` where - `\alpha` is a root of `f(x)`. The minimal polynomial `f(x)` must be - irreducible. - """ - - @staticmethod - def new(poly) -> gr_nf_ctx: - """Create a new context for number fields. - - The doctests below are commented out because they crash under WASM: - - https://github.com/flintlib/python-flint/issues/319 - - # >>> from flint.types._gr import gr_nf_ctx - # >>> Qa = gr_nf_ctx.new([-2, 0, 1]) - # >>> Qa - # gr_nf_ctx(x^2 + (-2)) - # >>> Qa.modulus() - # x^2 + (-2) - # >>> a = Qa.gen() - # >>> a - # a - # >>> a**2 - # 2 - # >>> (1 + a) ** 2 - # 2*a+3 - # >>> (1 + a) / 2 - # 1/2*a+1/2 - """ - poly = fmpq_poly(poly) - return gr_nf_ctx._new(poly) - - def modulus(self): - cdef fmpq_poly poly = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_init(poly.val) - fmpq_poly_set(poly.val, self.poly) - return poly - - def __repr__(self): - return f"gr_nf_ctx({self.modulus()})" - - -@cython.no_gc -cdef class gr_nf_fmpz_poly_ctx(gr_scalar_ctx): - r"""Context for number fields, `\mathbb{Q}(\alpha)`. - - The number field is defined by a minimal polynomial `f(x)` in - `\mathbb{Z}[x]` and represents the ring `\mathbb{Z}[\alpha]` where - `\alpha` is a root of `f(x)`. The minimal polynomial `f(x)` must be - irreducible. - """ - - @staticmethod - def new(poly) -> gr_nf_fmpz_poly_ctx: - """Create a new context for number fields. - - The doctests below are commented out because they crash under WASM: - - https://github.com/flintlib/python-flint/issues/319 - - # >>> from flint.types._gr import gr_nf_fmpz_poly_ctx - # >>> Qa = gr_nf_fmpz_poly_ctx.new([-2, 0, 1]) - # >>> Qa - # gr_nf_fmpz_poly_ctx(x^2 + (-2)) - # >>> Qa.modulus() - # x^2 + (-2) - # >>> a = Qa.gen() - # >>> a - # a - # >>> a**2 - # 2 - # >>> (1 + a) ** 2 - # 2*a+3 - """ - poly = fmpz_poly(poly) - return gr_nf_fmpz_poly_ctx._new(poly) - - def modulus(self): - cdef fmpz_poly poly = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_init(poly.val) - fmpz_poly_set(poly.val, self.poly) - return poly - - def __repr__(self): - return f"gr_nf_fmpz_poly_ctx({self.modulus()})" - - -@cython.no_gc -cdef class gr_real_qqbar_ctx(gr_scalar_ctx): - r"""Context for real algebraic numbers, `\mathbb{R} \cap \overline{\mathbb{Q}}`. - - The real algebraic numbers are a subset of the real numbers that are roots - of non-zero polynomials with integer coefficients. See - :class:`gr_complex_qqbar_ctx` for the full algebraic closure of the - rationals. See :class:`gr_nf_ctx` for number fields with a single - generator. - """ - @staticmethod - def new(deg_limit=-1, bits_limit=-1) -> gr_real_qqbar_ctx: - """Create a new context for real algebraic numbers. - - >>> from flint.types._gr import gr_real_qqbar_ctx - >>> R = gr_real_qqbar_ctx.new() - >>> R - gr_real_qqbar_ctx(-1, -1) - >>> R(2).sqrt() - Root a = 1.41421 of a^2-2 - """ - assert deg_limit == -1 and bits_limit == -1 or deg_limit > 0 and bits_limit > 0 - return gr_real_qqbar_ctx._new(deg_limit, bits_limit) - - def limits(self): - return {'deg_limit': self.deg_limit, 'bits_limit': self.bits_limit} - - def __repr__(self): - return f"gr_real_qqbar_ctx({self.deg_limit}, {self.bits_limit})" - - -@cython.no_gc -cdef class gr_complex_qqbar_ctx(gr_scalar_ctx): - r"""Context for algebraic numbers, `\overline{\mathbb{Q}}`. - - The algebraic numbers are a field that contains the rationals and all roots - of non-zero polynomials with integer coefficients. See - :class:`gr_real_qqbar_ctx` for the real algebraic numbers, - :class:`gr_nf_ctx` for number fields with a single generator. - """ - @staticmethod - def new(deg_limit=-1, bits_limit=-1) -> gr_complex_qqbar_ctx: - """Create a new context for algebraic numbers. - - >>> from flint.types._gr import gr_complex_qqbar_ctx - >>> C = gr_complex_qqbar_ctx.new() - >>> C - gr_complex_qqbar_ctx(-1, -1) - >>> C(-2).sqrt() - Root a = 1.41421*I of a^2+2 - """ - assert deg_limit == -1 and bits_limit == -1 or deg_limit > 0 and bits_limit > 0 - return gr_complex_qqbar_ctx._new(deg_limit, bits_limit) - - def limits(self): - return {'deg_limit': self.deg_limit, 'bits_limit': self.bits_limit} - - def __repr__(self): - return f"gr_complex_qqbar_ctx({self.deg_limit}, {self.bits_limit})" - - -@cython.no_gc -cdef class gr_real_ca_ctx(gr_scalar_ctx): - r"""Context for calcium exact real numbers, `\mathbb{R}`.""" - - @staticmethod - def new(**options) -> gr_real_ca_ctx: - """Create a new context for calcium exact real numbers. - - >>> from flint.types._gr import gr_real_ca_ctx - >>> R = gr_real_ca_ctx.new() - >>> R - gr_real_ca_ctx({}) - >>> R(2).sqrt() - 1.41421 {a where a = 1.41421 [a^2-2=0]} - """ - return gr_real_ca_ctx._new(options) - - def __repr__(self): - return f"gr_real_ca_ctx({self.options})" - - -@cython.no_gc -cdef class gr_complex_ca_ctx(gr_scalar_ctx): - r"""Context for calcium exact complex numbers, `\mathbb{C}`.""" - - @staticmethod - def new(**options) -> gr_complex_ca_ctx: - """Create a new context for calcium exact complex numbers. - - >>> from flint.types._gr import gr_complex_ca_ctx - >>> C = gr_complex_ca_ctx.new() - >>> C - gr_complex_ca_ctx({}) - >>> C(2).sqrt() - 1.41421 {a where a = 1.41421 [a^2-2=0]} - """ - return gr_complex_ca_ctx._new(options) - - def __repr__(self): - return f"gr_complex_ca_ctx({self.options})" - - -@cython.no_gc -cdef class gr_real_algebraic_ca_ctx(gr_scalar_ctx): - r"""Context for calcium exact real algebraic numbers, `\mathbb{R} \cap \overline{\mathbb{Q}}`.""" - - @staticmethod - def new(**options) -> gr_real_algebraic_ca_ctx: - """Create a new context for calcium exact real algebraic numbers. - - >>> from flint.types._gr import gr_real_algebraic_ca_ctx - >>> R = gr_real_algebraic_ca_ctx.new() - >>> R - gr_real_algebraic_ca_ctx({}) - >>> R(2).sqrt() - 1.41421 {a where a = 1.41421 [a^2-2=0]} - """ - return gr_real_algebraic_ca_ctx._new(options) - - def __repr__(self): - return f"gr_real_algebraic_ca_ctx({self.options})" - - -@cython.no_gc -cdef class gr_complex_algebraic_ca_ctx(gr_scalar_ctx): - r"""Context for calcium exact complex algebraic numbers, `\overline{\mathbb{Q}}`.""" - - @staticmethod - def new(**options) -> gr_complex_algebraic_ca_ctx: - """Create a new context for calcium exact complex algebraic numbers. - - >>> from flint.types._gr import gr_complex_algebraic_ca_ctx - >>> C = gr_complex_algebraic_ca_ctx.new() - >>> C - gr_complex_algebraic_ca_ctx({}) - >>> C(2).sqrt() - 1.41421 {a where a = 1.41421 [a^2-2=0]} - """ - return gr_complex_algebraic_ca_ctx._new(options) - - def __repr__(self): - return f"gr_complex_algebraic_ca_ctx({self.options})" - - -@cython.no_gc -cdef class gr_complex_extended_ca_ctx(gr_scalar_ctx): - r"""Context for calcium exact extended complex numbers, `\mathbb{C} \cup \{\infty\}`.""" - - @staticmethod - def new(**options) -> gr_complex_extended_ca_ctx: - """Create a new context for calcium exact extended complex numbers. - - >>> from flint.types._gr import gr_complex_extended_ca_ctx - >>> C = gr_complex_extended_ca_ctx.new() - >>> C - gr_complex_extended_ca_ctx({}) - >>> C(1) / 0 - UnsignedInfinity - """ - return gr_complex_extended_ca_ctx._new(options) - - def __repr__(self): - return f"gr_complex_extended_ca_ctx({self.options})" - - -@cython.no_gc -cdef class gr_real_float_arf_ctx(gr_scalar_ctx): - r"""Context for arbitrary precision approximate real numbers, `\mathbb{R}`.""" - - @staticmethod - def new(prec) -> gr_real_float_arf_ctx: - """Create a new context for arbitrary precision approximate real numbers. - - >>> from flint.types._gr import gr_real_float_arf_ctx - >>> R = gr_real_float_arf_ctx.new(10) - >>> R - gr_real_float_arf_ctx(10) - >>> R(2).sqrt() - 1.414 - >>> R.real_prec = 20 - >>> R(2).sqrt() - 1.414213 - """ - return gr_real_float_arf_ctx._new(prec) - - def __repr__(self): - return f"gr_real_float_arf_ctx({self.prec})" - - -@cython.no_gc -cdef class gr_complex_float_acf_ctx(gr_scalar_ctx): - r"""Context for arbitrary precision approximate complex numbers, `\mathbb{C}`.""" - - @staticmethod - def new(prec) -> gr_complex_float_acf_ctx: - """Create a new context for arbitrary precision approximate complex numbers. - - >>> from flint.types._gr import gr_complex_float_acf_ctx - >>> C = gr_complex_float_acf_ctx.new(10) - >>> C - gr_complex_float_acf_ctx(10) - >>> C(-2).sqrt() - 1.414*I - >>> C.real_prec = 20 - >>> C(-2).sqrt() - 1.414213*I - """ - return gr_complex_float_acf_ctx._new(prec) - - def __repr__(self): - return f"gr_complex_float_acf_ctx({self.prec})" - - -@cython.no_gc -cdef class gr_real_arb_ctx(gr_scalar_ctx): - r"""Context for Arb arbitrary precision real ball arithmetic, `\mathbb{R}`.""" - - @staticmethod - def new(prec) -> gr_real_arb_ctx: - """Create a new context for arbitrary precision real ball arithmetic. - - >>> from flint.types._gr import gr_real_arb_ctx - >>> R = gr_real_arb_ctx.new(10) - >>> R - gr_real_arb_ctx(10) - >>> R(2).sqrt() - [1.41 +/- 6.02e-3] - >>> R.real_prec = 20 - >>> R(2).sqrt() - [1.41421 +/- 5.09e-6] - """ - return gr_real_arb_ctx._new(prec) - - def __repr__(self): - return f"gr_real_arb_ctx({self.prec})" - - -@cython.no_gc -cdef class gr_complex_acb_ctx(gr_scalar_ctx): - r"""Context for Arb arbitrary precision complex ball arithmetic, `\mathbb{C}`.""" - - @staticmethod - def new(prec) -> gr_complex_acb_ctx: - """Create a new context for arbitrary precision complex ball arithmetic. - - >>> from flint.types._gr import gr_complex_acb_ctx - >>> C = gr_complex_acb_ctx.new(10) - >>> C - gr_complex_acb_ctx(10) - >>> C(-2).sqrt() - [1.41 +/- 6.02e-3]*I - >>> C.real_prec = 20 - >>> C(-2).sqrt() - [1.41421 +/- 5.09e-6]*I - """ - return gr_complex_acb_ctx._new(prec) - - def __repr__(self): - return f"gr_complex_acb_ctx({self.prec})" - - -@cython.no_gc -cdef class gr_gr_poly_ctx(gr_poly_ctx): - r"""Context for dense univariate polynomial rings, `\mathbb{D}[x]`.""" - - @staticmethod - def new(base_ring) -> gr_gr_poly_ctx: - """Create a new context for dense univariate polynomial rings. - - >>> from flint.types._gr import gr_fmpz_ctx, gr_gr_poly_ctx - >>> Z = gr_fmpz_ctx - >>> R = gr_gr_poly_ctx.new(Z) - >>> R - gr_gr_poly_ctx(gr_fmpz_ctx) - >>> R.base_ring - gr_fmpz_ctx - >>> R.gen() - x - >>> x = R.gen() - >>> (1 + x) ** 2 - 1 + 2*x + x^2 - """ - return gr_gr_poly_ctx._new(base_ring) - - def __repr__(self): - return f"gr_gr_poly_ctx({self.base_ring})" - - @property - def base_ring(self): - return self.base_ctx - - -@cython.no_gc -cdef class gr_gr_mpoly_ctx(gr_mpoly_ctx): - r"""Context for dense multivariate polynomial rings, `\mathbb{D}[x, y, ...]`.""" - - @staticmethod - def new(base_ring, names, order=None) -> gr_gr_mpoly_ctx: - """Create a new context for dense multivariate polynomial rings. - - # >>> from flint.types._gr import gr_fmpzi_ctx, gr_gr_mpoly_ctx - # >>> ZI = gr_fmpzi_ctx - # >>> R = gr_gr_mpoly_ctx.new(ZI, ['x', 'y']) - # >>> R - # gr_gr_mpoly_ctx(gr_fmpzi_ctx, ('x', 'y'), Ordering.lex) - # >>> R.base_ring - # gr_fmpzi_ctx - # >>> R.names - # ('x', 'y') - # >>> R.nvars - # 2 - # >>> R.order - # - # >>> R.gens() - # [x, y] - # >>> I, [x, y] = ZI.gen(), R.gens() - # >>> (I + x + y) ** 2 - # x^2 + 2*x*y + (2*I)*x + y^2 + (2*I)*y - 1 - """ - if order is None: - order = Ordering.lex - return gr_gr_mpoly_ctx._new(base_ring, tuple(names), order) - - def __repr__(self): - return f"gr_gr_mpoly_ctx({self.base_ring}, {self.names}, {self.order})" - - @property - def base_ring(self): - return self.base_ctx - - @property - def names(self): - return self._names - - @property - def nvars(self): - return self._nvars - - @property - def order(self): - return ordering_c_to_py(self._order) - - -# @cython.no_gc -# cdef class gr_mpoly_q_ctx(gr_mpoly_ctx): -# -# @staticmethod -# def new(nvars, order=None) -> gr_gr_mpoly_q_ctx: -# if order is None: -# order = Ordering.lex -# return gr_mpoly_q_ctx._new(nvars, order) -# -# def __repr__(self): -# return f"gr_mpoly_q_ctx({self.nvars}, {self.order})" -# -# @property -# def nvars(self): -# return self._nvars -# -# @property -# def order(self): -# return ordering_c_to_py(self._order) - - -# @cython.no_gc -# cdef class gr_series_mod_gr_poly_ctx(gr_ctx): -# -# @staticmethod -# def new(base_ring, n) -> gr_series_mod_gr_poly_ctx: -# return gr_series_mod_gr_poly_ctx._new(base_ring, n) -# -# def __repr__(self): -# return f"gr_series_mod_gr_poly_ctx({self.base_ring}, {self.nvars})" -# -# @property -# def base_ring(self): -# return self.base_ctx -# -# @property -# def n(self): -# return self._n - - -@cython.no_gc -cdef class gr_series_ctx(gr_ctx): - r"""Context for series with precision `n`, `\mathbb{D}[[x]]`.""" - - @staticmethod - def new(base_ring, prec) -> gr_series_ctx: - """Create a new context for series with precision `n`. - - >>> from flint.types._gr import gr_fmpz_ctx, gr_series_ctx - >>> Z = gr_fmpz_ctx - >>> R = gr_series_ctx.new(Z, 10) - >>> R - gr_series_ctx(gr_fmpz_ctx, 10) - >>> R.base_ring - gr_fmpz_ctx - >>> R.prec - 10 - >>> x = R.gen() - >>> 1 / (1 - x) - 1 + x + x^2 + x^3 + x^4 + x^5 + x^6 + x^7 + x^8 + x^9 + O(x^10) - """ - return gr_series_ctx._new(base_ring, prec) - - def __repr__(self): - return f"gr_series_ctx({self.base_ring}, {self.prec})" - - @property - def base_ring(self): - return self.base_ctx - - @property - def prec(self): - return self._prec - - -@cython.no_gc -cdef class gr(flint_scalar): - """Type of elements of :class:`gr_ctx` domains.""" - - def __dealloc__(self): - if self._init: - self._init = False - gr_heap_clear(self.pval, self.ctx.ctx_t) - - def __repr__(self): - return self.ctx.to_str(self) - - def parent(self) -> gr_ctx: - """ - Return the parent context. - - >>> 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) - """ - return self.ctx - - def is_zero(self): - """Return whether the element is zero (may return ``None``). - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(0).is_zero() - True - """ - return truth_to_py(self._is_zero()) - - def is_one(self): - """Return whether the element is one (may return ``None``). - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(1).is_one() - True - """ - return truth_to_py(self._is_one()) - - def is_neg_one(self): - """Return whether the element is negative one (may return ``None``). - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(-1).is_neg_one() - True - """ - return truth_to_py(self._is_neg_one()) - -# def is_integer(self): -# """Return whether the element is an integer (may return ``None``). -# -# >>> from flint.types._gr import gr_fmpq_ctx as Q -# >>> Q(2).is_integer() -# True -# >>> Q(2, 3).is_integer() -# False -# """ -# return truth_to_py(self._is_integer()) -# -# def is_rational(self): -# """Return whether the element is a rational number (may return ``None``). -# -# >>> from flint.types._gr import gr_nf_ctx -# >>> Qa = gr_nf_ctx.new([-2, 0, 1]) -# >>> a = Qa.gen() -# >>> a.is_rational() -# False -# >>> (a**2).is_rational() -# True -# """ -# return truth_to_py(self._is_rational()) - - def __bool__(self): - return not truth_to_bool(self._is_zero()) - - def __richcmp__(self, other, int op): - cdef int err - cdef gr other_gr - cdef truth_t res - - if isinstance(other, int): - other_gr = self.ctx.new_gr() - err = gr_set_si(other_gr.pval, other, self.ctx.ctx_t) - if err != GR_SUCCESS: - raise self.ctx._error(err, "Cannot set gr from int") - elif isinstance(other, gr): - other_gr = other - else: - raise NotImplementedError("Cannot compare gr with non-gr objects") - - if self.ctx != other_gr.ctx: - raise NotImplementedError("Cannot compare gr with different contexts") - - if op == 0: - raise NotImplementedError("Cannot compare gr with <") - # res = self._lt(other_gr) - elif op == 1: - raise NotImplementedError("Cannot compare gr with <=") - # res = self._le(other_gr) - elif op == 2: - res = self._equal(other_gr) - elif op == 3: - res = self._equal(other_gr) - if res == T_TRUE: - res = T_FALSE - elif res == T_FALSE: - res = T_TRUE - elif op == 4: - raise NotImplementedError("Cannot compare gr with >") - # res = self._gt(other_gr) - elif op == 5: - raise NotImplementedError("Cannot compare gr with >=") - # res = self._ge(other_gr) - else: - assert False, "Invalid rich comparison operator" - - return truth_to_py(res) - - def __neg__(self) -> gr: - return self._neg() - - # XXX: Maybe +a should return a copy or for arb it should round... - # def __pos__(self) -> gr: - # return self - - def __add__(self, other) -> gr: - cdef gr other_gr - if isinstance(other, gr): - other_gr = other - if self.ctx != other_gr.ctx: - raise ValueError("Cannot add elements from different contexts") - return self._add(other_gr) - elif isinstance(other, int): - return self._add_si(other) - else: - return NotImplemented - - def __radd__(self, other) -> gr: - if isinstance(other, int): - return self._add_si(other) - else: - return NotImplemented - - def __sub__(self, other) -> gr: - cdef gr other_gr - if isinstance(other, gr): - other_gr = other - if self.ctx != other_gr.ctx: - raise ValueError("Cannot subtract elements from different contexts") - return self._sub(other_gr) - elif isinstance(other, int): - return self._sub_si(other) - else: - return NotImplemented - - def __rsub__(self, other) -> gr: - if isinstance(other, int): - return self._neg()._add_si(other) - else: - return NotImplemented - - def __mul__(self, other) -> gr: - cdef gr other_gr - if isinstance(other, gr): - other_gr = other - if self.ctx != other_gr.ctx: - raise ValueError("Cannot multiply elements from different contexts") - return self._mul(other_gr) - elif isinstance(other, int): - return self._mul_si(other) - else: - return NotImplemented - - def __rmul__(self, other) -> gr: - if isinstance(other, int): - return self._mul_si(other) - else: - return NotImplemented - - def __truediv__(self, other) -> gr: - cdef gr other_gr - if isinstance(other, gr): - other_gr = other - if self.ctx != other_gr.ctx: - raise ValueError("Cannot divide elements from different contexts") - return self._div(other_gr) - elif isinstance(other, int): - return self._div_si(other) - else: - return NotImplemented - - def __rtruediv__(self, other) -> gr: - if isinstance(other, int): - return self._div_si(other)._inv() - else: - return NotImplemented - - def __pow__(self, other) -> gr: - return self.ctx.pow(self, other) - - def is_square(self): - """Return whether the element is a square (may return ``None``). - - >>> from flint.types._gr import gr_fmpq_ctx as Q - >>> Q(2).is_square() - False - >>> Q(4).is_square() - True - >>> Q(4).sqrt() - 2 - """ - return self.ctx.is_square(self) - - def sqrt(self): - """Return the square root of the element if it exists. - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(4).sqrt() - 2 - """ - return self.ctx.sqrt(self) - - def rsqrt(self): - """Return the reciprocal square root of the element if it exists. - - >>> from flint.types._gr import gr_fmpq_ctx as Q - >>> Q(4).rsqrt() - 1/2 - """ - return self.ctx.rsqrt(self) - - def gcd(self, other): - """Return the greatest common divisor of two elements. - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(4).gcd(Z(6)) - 2 - """ - cdef gr other_gr - if not isinstance(other, gr): - raise TypeError("gcd when other is not gr.") - other_gr = other - if not self.ctx == other_gr.ctx: - raise TypeError("gcd of gr with different contexts.") - return self._gcd(other_gr) - - def lcm(self, other): - """Return the least common multiple of two elements. - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(4).lcm(Z(6)) - 12 - """ - cdef gr other_gr - if not isinstance(other, gr): - raise TypeError("gcd when other is not gr.") - other_gr = other - if not self.ctx == other_gr.ctx: - raise TypeError("gcd of gr with different contexts.") - return self.ctx.lcm(self, other_gr) - - def factor(self): - """Return the factorization of the element. - - >>> from flint.types._gr import gr_fmpz_ctx as Z - >>> Z(12).factor() - (1, [(2, 2), (3, 1)]) - """ - return self.ctx.factor(self) - - def numer(self) -> gr: - """Return the numerator of the element. - - >>> from flint.types._gr import gr_fmpq_ctx as Q - >>> q = Q(2) / 3 - >>> q - 2/3 - >>> q.numer() - 2 - - See also :meth:`denom`. - """ - return self.ctx.numerator(self) - - def denom(self) -> gr: - """Return the denominator of the element. - - >>> from flint.types._gr import gr_fmpq_ctx as Q - >>> q = Q(2) / 3 - >>> q - 2/3 - >>> q.denom() - 3 - - See also :meth:`numer`. - """ - return self.ctx.denominator(self) - - def __floor__(self) -> gr: - return self.ctx.floor(self) - - def __ceil__(self) -> gr: - return self.ctx.ceil(self) - - def __trunc__(self) -> gr: - return self.ctx.trunc(self) - - def __round__(self, ndigits: int = 0) -> gr: - if ndigits != 0: - raise NotImplementedError("Rounding to a specific number of digits is not supported") - return self.ctx.nint(self) - - # def __int__(self) -> int: - # return self._floor().to_int() - - # def __float__(self) -> float: - # return ... - - def __abs__(self) -> gr: - return self.ctx.abs(self) - - def conjugate(self) -> gr: - """Return complex conjugate of the element. - - >>> from flint.types._gr import gr_fmpzi_ctx as ZI - >>> I = ZI.gen() - >>> (1 + I).conjugate() - (1-I) - """ - return self.ctx.conj(self) - - @property - def real(self) -> gr: - """Return the real part of the element. - - >>> from flint.types._gr import gr_fmpzi_ctx as ZI - >>> I = ZI.gen() - >>> (1 + I).real - 1 - """ - return self.ctx.re(self) - - @property - def imag(self) -> gr: - """Return the imaginary part of the element. - - >>> from flint.types._gr import gr_fmpzi_ctx as ZI - >>> I = ZI.gen() - >>> (1 + I).imag - 1 - """ - return self.ctx.im(self) - - # XXX: Return -1, 0, 1 as int? - def sgn(self) -> gr: - """Return the sign of the element. - - >>> from flint.types._gr import gr_fmpq_ctx as Q - >>> Q(2).sgn() - 1 - >>> Q(-2).sgn() - -1 - >>> Q(0).sgn() - 0 - """ - return self.ctx.sgn(self) - - def csgn(self) -> gr: - """Return the complex sign of the element. - - >>> from flint.types._gr import gr_complex_acb_ctx - >>> C = gr_complex_acb_ctx.new(10) - >>> (1 + C.i()).csgn() # doctest: +SKIP - 1 - """ - return self.ctx.csgn(self) - - def arg(self) -> gr: - """Return the argument of the element. - - >>> from flint.types._gr import gr_complex_acb_ctx - >>> C = gr_complex_acb_ctx.new(10) - >>> (1 + C.i()).arg() - [0.785 +/- 6.45e-4] - """ - return self.ctx.arg(self) diff --git a/src/flint/types/acb.pxd b/src/flint/types/acb.pxd deleted file mode 100644 index e5720e32..00000000 --- a/src/flint/types/acb.pxd +++ /dev/null @@ -1,11 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.flintlib.functions.acb cimport acb_t - -cdef any_as_acb(x) -cdef any_as_acb_or_notimplemented(x) -cdef int acb_set_python(acb_t x, obj, bint allow_conversion) -cdef class acb(flint_scalar): - cdef acb_t val - cpdef bint is_zero(self) - cpdef bint is_finite(self) - cpdef bint is_exact(self) diff --git a/src/flint/types/acb.pyx b/src/flint/types/acb.pyx deleted file mode 100644 index cc3b149c..00000000 --- a/src/flint/types/acb.pyx +++ /dev/null @@ -1,2782 +0,0 @@ -from cpython.complex cimport PyComplex_Check -from cpython.complex cimport PyComplex_RealAsDouble -from cpython.complex cimport PyComplex_ImagAsDouble -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_base cimport flint_scalar -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_context cimport thectx -from flint.types.arb cimport arb_set_mpmath_mpf -from flint.types.arb cimport arb_set_python -from flint.types.arb cimport any_as_arb -from flint.types.arb cimport arb -from flint.types.fmpz cimport fmpz -from flint.types.fmpz cimport any_as_fmpz -from flint.types.dirichlet cimport dirichlet_char - -from flint.flintlib.types.flint cimport FMPZ_TMP, FMPZ_REF, FMPZ_UNKNOWN -from flint.flintlib.functions.mag cimport * -from flint.flintlib.functions.arb cimport * -from flint.flintlib.types.arb cimport arb_midref, arb_radref -from flint.flintlib.functions.arf cimport * -from flint.flintlib.types.arf cimport ARF_RND_NEAR -from flint.flintlib.functions.acb cimport * -from flint.flintlib.types.acb cimport acb_struct, acb_realref, acb_imagref -from flint.flintlib.functions.acb_modular cimport * -from flint.flintlib.functions.acb_hypgeom cimport * -from flint.flintlib.functions.acb_dirichlet cimport * -from flint.flintlib.functions.acb_elliptic cimport * -from flint.flintlib.functions.acb_calc cimport * -from flint.flintlib.functions.acb_dft cimport * - -cimport libc.stdlib -cimport cython - -ctx = thectx - -cdef int acb_set_python(acb_t x, obj, bint allow_conversion): - cdef double re, im - - if typecheck(obj, acb): - acb_set(x, (obj).val) - return 1 - - if arb_set_python(acb_realref(x), obj, allow_conversion): - arb_zero(acb_imagref(x)) - return 1 - - if PyComplex_Check(obj): - re = PyComplex_RealAsDouble(obj) - im = PyComplex_ImagAsDouble(obj) - arf_set_d(arb_midref(acb_realref(x)), re) - arf_set_d(arb_midref(acb_imagref(x)), im) - mag_zero(arb_radref(acb_realref(x))) - mag_zero(arb_radref(acb_imagref(x))) - return 1 - - if hasattr(obj, "_mpc_"): - xre, xim = obj._mpc_ - arb_set_mpmath_mpf(acb_realref(x), xre) - arb_set_mpmath_mpf(acb_imagref(x), xim) - return 1 - - return 0 - -cdef inline int acb_set_any_ref(acb_t x, obj): - if typecheck(obj, acb): # should be exact check? - x[0] = (obj).val[0] - return FMPZ_REF - - acb_init(x) - if acb_set_python(x, obj, 0): - return FMPZ_TMP - - return FMPZ_UNKNOWN - -cdef any_as_acb(x): - cdef acb t - if typecheck(x, acb): - return x - t = acb() - if acb_set_python(t.val, x, 0) == 0: - raise TypeError("cannot create acb from type %s" % type(x)) - return t - -cdef any_as_acb_or_notimplemented(x): - cdef acb t - if typecheck(x, acb): - return x - t = acb() - if acb_set_python(t.val, x, 0) == 0: - return NotImplemented - return t - - -# Copied with modifications from sage/rings/complex_arb.pyx -@cython.internal -cdef class IntegrationContext: - cdef object f - cdef object exn_type - cdef object exn_obj - cdef object exn_tb - -cdef int acb_calc_func_callback(acb_ptr out, const acb_t inp, void * param, long order, long prec): - cdef IntegrationContext ictx - cdef acb x - try: - ictx = param - if ictx.exn_type is not None or order >= 2: - acb_indeterminate(out) - return 0 - x = acb.__new__(acb) - acb_set(x.val, inp) - try: - y = ictx.f(x, (order == 1)) - if not typecheck(y, acb): - raise TypeError("integrand must return an acb") - acb_set(out, ( y).val) - except (TypeError, ValueError): - import sys - ictx.exn_type, ictx.exn_obj, ictx.exn_tb = sys.exc_info() - acb_indeterminate(out) - return 0 - finally: - pass - - -cdef class acb(flint_scalar): - r""" - An *acb* represents a complex number by a rectangular enclosure - consisting of *arb* balls for the real and imaginary parts. - - >>> from flint import fmpq - >>> acb(2) - 2.00000000000000 - >>> acb(2+3j) - 2.00000000000000 + 3.00000000000000j - >>> acb("2 +/- 0.001", fmpq(2,3)) - [2.00 +/- 1.01e-3] + [0.666666666666667 +/- 4.82e-16]j - >>> acb(-1) ** 0.25 - [0.707106781186547 +/- 6.14e-16] + [0.707106781186547 +/- 6.15e-16]j - """ - -# cdef acb_t val - - def __cinit__(self): - acb_init(self.val) - - def __dealloc__(self): - acb_clear(self.val) - - def __init__(self, real=None, imag=None): - if real is not None: - if not acb_set_python(self.val, real, 1): - raise TypeError("cannot create acb from type %s" % type(real)) - if imag is not None: - if not arb_is_zero(acb_imagref(self.val)): - raise ValueError("must create acb from one complex number or two real numbers") - if not arb_set_python(acb_imagref(self.val), imag, 1): - raise TypeError("cannot create arb from type %s" % type(imag)) - - cpdef bint is_zero(self): - return acb_is_zero(self.val) - - cpdef bint is_finite(self): - return acb_is_finite(self.val) - - cpdef bint is_exact(self): - return acb_is_exact(self.val) - - @property - def real(self): - cdef arb re = arb() - arb_set(re.val, acb_realref(self.val)) - return re - - @property - def imag(self): - cdef arb im = arb() - arb_set(im.val, acb_imagref(self.val)) - return im - - @property - def _mpc_(self): - return (self.real._mpf_, self.imag._mpf_) - - def __richcmp__(s, t, int op): - cdef acb_struct tval[1] - cdef bint res - cdef int ttype - if not (op == 2 or op == 3): - raise ValueError("comparing complex numbers") - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - if op == 2: - res = acb_eq(s.val, tval) - else: - res = acb_ne(s.val, tval) - if ttype == FMPZ_TMP: - acb_clear(tval) - return res - - def __contains__(self, other): - other = any_as_acb(other) - return acb_contains(self.val, (other).val) - - def contains(self, other): - other = any_as_acb(other) - return bool(acb_contains(self.val, (other).val)) - - def contains_interior(self, other): - other = any_as_acb(other) - return bool(acb_contains_interior(self.val, (other).val)) - - def overlaps(self, other): - other = any_as_acb(other) - return bool(acb_overlaps((self).val, (other).val)) - - def contains_integer(self): - return bool(acb_contains_int(self.val)) - - def mid(self): - """ - Returns an exact *acb* representing the midpoint of *self*: - - >>> acb("1 +/- 0.3", "2 +/- 0.4").mid() - 1.00000000000000 + 2.00000000000000j - """ - cdef acb u = acb() - arf_set(arb_midref(acb_realref(u.val)), arb_midref(acb_realref(self.val))) - arf_set(arb_midref(acb_imagref(u.val)), arb_midref(acb_imagref(self.val))) - return u - - def rad(self): - """ - Returns an upper bound for the radius (magnitude of error) of self as an *arb*. - - >>> print(acb("1 +/- 0.3", "2 +/- 0.4").rad().str(5, radius=False)) - 0.50000 - """ - cdef arb u = arb() - mag_hypot(arb_radref(u.val), arb_radref(acb_realref(self.val)), arb_radref(acb_imagref(self.val))) - arf_set_mag(arb_midref(u.val), arb_radref(u.val)) - mag_zero(arb_radref(u.val)) - return u - - def complex_rad(self): - """ - Returns an *acb* representing the radii of the real and imaginary parts of *self* - together a single complex number. - - >>> print(acb("1 +/- 0.3", "2 +/- 0.4").complex_rad().str(5, radius=False)) - 0.30000 + 0.40000j - """ - cdef acb u = acb() - arf_set_mag(arb_midref(acb_realref(u.val)), arb_radref(acb_realref(self.val))) - arf_set_mag(arb_midref(acb_imagref(u.val)), arb_radref(acb_imagref(self.val))) - return u - - def repr(self): - real = self.real - imag = self.imag - if imag.is_zero(): - return "acb(%s)" % real.repr() - else: - return "acb(%s, %s)" % (real.repr(), imag.repr()) - - def str(self, *args, **kwargs): - real = self.real - imag = self.imag - if imag.is_zero(): - return real.str(*args, **kwargs) - elif real.is_zero(): - return imag.str(*args, **kwargs) + "j" - else: - re = real.str(*args, **kwargs) - im = imag.str(*args, **kwargs) - if im.startswith("-"): - return "%s - %sj" % (re, im[1:]) - else: - return "%s + %sj" % (re, im) - - def __complex__(self): - return complex(arf_get_d(arb_midref(acb_realref(self.val)), ARF_RND_NEAR), - arf_get_d(arb_midref(acb_imagref(self.val)), ARF_RND_NEAR)) - - def __pos__(self): - res = acb.__new__(acb) - acb_set_round((res).val, (self).val, getprec()) - return res - - def __neg__(self): - res = acb.__new__(acb) - acb_neg_round((res).val, (self).val, getprec()) - return res - - def neg(self, bint exact=False): - res = acb.__new__(acb) - if exact: - acb_set((res).val, (self).val) - else: - acb_set_round((res).val, (self).val, getprec()) - return res - - def conjugate(self, bint exact=False): - res = acb.__new__(acb) - if exact: - acb_conj((res).val, (self).val) - else: - acb_set_round((res).val, (self).val, getprec()) - acb_conj((res).val, (res).val) - return res - - def __abs__(self): - res = arb.__new__(arb) - acb_abs((res).val, (self).val, getprec()) - return res - - def abs_lower(self): - """ - Lower bound for the absolute value of *self*. - The output is an *arb* holding an exact floating-point number - that has been rounded down to the current precision. - - >>> print(acb(3, "-5 +/- 2").abs_lower().str(5, radius=False)) - 4.2426 - """ - cdef arb x = arb() - acb_get_abs_lbound_arf(arb_midref(x.val), self.val, getprec()) - return x - - def abs_upper(self): - """ - Upper bound for the absolute value of *self*. - The output is an *arb* holding an exact floating-point number - that has been rounded up to the current precision. - - >>> print(acb(3, "-5 +/- 2").abs_upper().str(5, radius=False)) - 7.6158 - """ - cdef arb x = arb() - acb_get_abs_ubound_arf(arb_midref(x.val), self.val, getprec()) - return x - - def csgn(self): - """ - Complex sign function defined as a piecewise extension of - the real sign function. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).csgn(), dps=25) - 1.000000000000000000000000 - >>> showgood(lambda: acb(-1).csgn(), dps=25) - -1.000000000000000000000000 - """ - res = arb.__new__(arb) - acb_csgn((res).val, (self).val) - return res - - def sgn(self): - """ - Complex sign function. - - >>> from flint import showgood - >>> showgood(lambda: acb(-1).sgn(), dps=25) - -1.000000000000000000000000 - >>> showgood(lambda: acb(5,5).sgn(), dps=25) - 0.7071067811865475244008444 + 0.7071067811865475244008444j - >>> showgood(lambda: acb(0).sgn(), dps=25) - 0 - """ - res = acb.__new__(acb) - acb_sgn((res).val, (self).val, getprec()) - return res - - def arg(self): - """ - Complex argument (phase). - - >>> from flint import showgood - >>> showgood(lambda: acb("3.3").arg(), dps=25) - 0 - >>> showgood(lambda: acb(-1).arg(), dps=25) - 3.141592653589793238462643 - >>> acb(-1, "+/- 1").arg() - [+/- 3.15] - """ - res = arb.__new__(arb) - acb_arg((res).val, (self).val, getprec()) - return res - - def __add__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_add((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __radd__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_add((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __sub__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_sub((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __rsub__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_sub((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __mul__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_mul((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __rmul__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_mul((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __truediv__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_div((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __rtruediv__(s, t): - cdef acb_struct tval[1] - cdef int ttype - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_div((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __pow__(s, t, u): - cdef acb_struct tval[1] - cdef int ttype - if u is not None: - raise ValueError("modular exponentiation of complex number") - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_pow((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def __rpow__(s, t, u): - cdef acb_struct tval[1] - cdef int ttype - if u is not None: - raise ValueError("modular exponentiation of complex number") - ttype = acb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = acb.__new__(acb) - acb_pow((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - acb_clear(tval) - return u - - def union(s, t): - v = acb.__new__(acb) - t = any_as_acb(t) - acb_union((v).val, (s).val, (t).val, getprec()) - return v - - def pow(s, t, bint analytic=False): - """ - Power `s^t`. - The *analytic* flag allows verifying that the branch cut is not - touched; this is useful for numerical integration. - - >>> acb.integral(lambda z, a: z.pow(acb("1/3")), -5-1j, -5+1j) # WRONG!!! - [+/- 5.03e-15] + [1.81137435753228 +/- 7.32e-15]j - >>> acb.integral(lambda z, a: z.pow(acb("1/3"), analytic=a), -5-1j, -5+1j) # doctest: +SKIP - [+/- 2.66e-14] + [1.8108516218463 +/- 3.58e-14]j - """ - t = any_as_acb(t) - u = acb.__new__(acb) - acb_pow_analytic((u).val, (s).val, (t).val, analytic, getprec()) - return u - - def log(s, bint analytic=False): - r""" - Natural logarithm `\log(s)`. - The *analytic* flag allows verifying that the branch cut is not - touched; this is useful for numerical integration. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).log(), dps=25) - 0.8047189562170501873003797 + 1.107148717794090503017065j - >>> showgood(lambda: acb(-5).log(), dps=25) - 1.609437912434100374600759 + 3.141592653589793238462643j - """ - u = acb.__new__(acb) - acb_log_analytic((u).val, (s).val, analytic, getprec()) - return u - - def log1p(s): - r""" - Computes `\log(1+s)`, accurately for small *s*. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).log1p(), dps=25) - 1.039720770839917964125848 + 0.7853981633974483096156608j - >>> showgood(lambda: acb(0,"1e-100000000000000000").log1p(), dps=25) - 5.000000000000000000000000e-200000000000000001 + 1.000000000000000000000000e-100000000000000000j - """ - u = acb.__new__(acb) - acb_log1p((u).val, (s).val, getprec()) - return u - - def asin(s): - r""" - Inverse sine `\operatorname{asin}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2).asin(), dps=25) - 1.570796326794896619231322 - 1.316957896924816708625046j - """ - u = acb.__new__(acb) - acb_asin((u).val, (s).val, getprec()) - return u - - def acos(s): - r""" - Inverse cosine `\operatorname{acos}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2).acos(), dps=25) - 1.316957896924816708625046j - """ - u = acb.__new__(acb) - acb_acos((u).val, (s).val, getprec()) - return u - - def atan(s): - r""" - Computes the inverse tangent `\operatorname{atan}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).atan(), dps=25) - 1.338972522294493561124194 + 0.4023594781085250936501898j - """ - u = acb.__new__(acb) - acb_atan((u).val, (s).val, getprec()) - return u - - def asinh(s): - r""" - Inverse hyperbolic sine `\operatorname{asinh}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).asinh(), dps=25) - 1.968637925793096291788665 + 0.9646585044076027920454111j - """ - u = acb.__new__(acb) - acb_asinh((u).val, (s).val, getprec()) - return u - - def acosh(s): - r""" - Inverse hyperbolic cosine `\operatorname{acosh}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).acosh(), dps=25) - 1.983387029916535432347077 + 1.000143542473797218521038j - """ - u = acb.__new__(acb) - acb_acosh((u).val, (s).val, getprec()) - return u - - def atanh(s): - r""" - Inverse hyperbolic tangent `\operatorname{atanh}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).atanh(), dps=25) - 0.1469466662255297520474328 + 1.338972522294493561124194j - """ - u = acb.__new__(acb) - acb_atanh((u).val, (s).val, getprec()) - return u - - def agm(s, t=None): - """ - Arithmetic-geometric mean `M(s,t)`, or `M(s) = M(s,1)` - if no extra parameter is passed. - - >>> from flint import showgood - >>> showgood(lambda: acb(2).agm(), dps=25) - 1.456791031046906869186432 - >>> showgood(lambda: acb(1,1).agm(), dps=25) - 1.049160528732780220531827 + 0.4781557460881612293261882j - >>> showgood(lambda: (acb(-95,-65)/100).agm(acb(684,747)/1000), dps=25) - -0.3711072435676023931065922 + 0.3199561471173686568561674j - """ - if t is None: - u = acb.__new__(acb) - acb_agm1((u).val, (s).val, getprec()) - return u - else: - t = acb(t) - u = acb.__new__(acb) - acb_agm((u).val, (s).val, (t).val, getprec()) - return u - - def gamma(s): - r""" - Gamma function `\Gamma(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).gamma(), dps=25) - 0.1519040026700361374481610 + 0.01980488016185498197191013j - """ - u = acb.__new__(acb) - acb_gamma((u).val, (s).val, getprec()) - return u - - def rgamma(s): - r""" - Reciprocal gamma function `1/\Gamma(s)`, avoiding - division by zero at the poles of the gamma function. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).rgamma(), dps=25) - 6.473073626019134501563613 - 0.8439438407732021454882999j - >>> print(acb(0).rgamma()) - 0 - >>> print(acb(-1).rgamma()) - 0 - """ - u = acb.__new__(acb) - acb_rgamma((u).val, (s).val, getprec()) - return u - - def lgamma(s): - r""" - Logarithmic gamma function `\log \Gamma(s)`. - The function is defined to be continuous away from the - negative half-axis and thus differs from `\log(\Gamma(s))` in general. - - >>> from flint import arb - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).lgamma(), dps=25) - -1.876078786430929341229996 + 0.1296463163097883113837075j - >>> showgood(lambda: (acb(0,10).lgamma() - acb(0,10).gamma().log()).imag / arb.pi(), dps=25) - 4.000000000000000000000000 - """ - u = acb.__new__(acb) - acb_lgamma((u).val, (s).val, getprec()) - return u - - def digamma(s): - r""" - Digamma function `\psi(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).digamma(), dps=25) - 0.7145915153739775266568699 + 1.320807282642230228386088j - """ - u = acb.__new__(acb) - acb_digamma((u).val, (s).val, getprec()) - return u - - def zeta(s, a=None): - r""" - Riemann zeta function `\zeta(s)`, or the Hurwitz - zeta function `\zeta(s,a)` if a second parameter is passed. - - >>> from flint import showgood - >>> showgood(lambda: acb(0.5,1000).zeta(), dps=25) - 0.3563343671943960550744025 + 0.9319978312329936651150604j - >>> showgood(lambda: acb(1,2).zeta(acb(2,3)), dps=25) - -2.953059572088556722876240 + 3.410962524512050603254574j - """ - if a is None: - u = acb.__new__(acb) - acb_zeta((u).val, (s).val, getprec()) - return u - else: - a = any_as_acb(a) - u = acb.__new__(acb) - acb_hurwitz_zeta((u).val, (s).val, (a).val, getprec()) - return u - - def lerch_phi(z, s, a): - r""" - Lerch transcendent `\Phi(z,s,a)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).lerch_phi(3, 4), dps=25) - 0.006872751459699249251487346 + 0.01112535314686351879432212j - """ - s = any_as_acb(s) - a = any_as_acb(a) - u = acb.__new__(acb) - acb_dirichlet_lerch_phi((u).val, (z).val, (s).val, (a).val, getprec()) - return u - - def dirichlet_l(s, chi): - cdef dirichlet_char cchar - if isinstance(chi, dirichlet_char): - cchar = chi - else: - cchar = dirichlet_char(chi[0], chi[1]) - u = acb.__new__(acb) - acb_dirichlet_l((u).val, (s).val, cchar.G.val, cchar.val, getprec()) - return u - - @staticmethod - def pi(): - r""" - Returns the constant `\pi` as an *acb*. - - >>> from flint import showgood - >>> showgood(lambda: acb.pi(), dps=25) - 3.141592653589793238462643 - """ - u = acb.__new__(acb) - acb_const_pi((u).val, getprec()) - return u - - def sqrt(s, bint analytic=False): - r""" - Square root `\sqrt{s}`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).sqrt(), dps=25) - 1.272019649514068964252422 + 0.7861513777574232860695586j - - The *analytic* flag allows verifying that the branch cut is not - touched; this is useful for numerical integration. - - >>> from flint import showgood - >>> showgood(lambda: acb.integral(lambda z, a: z.sqrt(), 0, 1).real, dps=25) # WRONG!!! - 0.6738873386790491615691993 - >>> showgood(lambda: acb.integral(lambda z, a: z.sqrt(analytic=a), 0, 1).real, dps=25) - 0.6666666666666666666666667 - - """ - u = acb.__new__(acb) - acb_sqrt_analytic((u).val, (s).val, analytic, getprec()) - return u - - def rsqrt(s, bint analytic=False): - r""" - Reciprocal square root `1/\sqrt{s}`. - - The *analytic* flag allows verifying that the branch cut is not - touched; this is useful for numerical integration. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).rsqrt(), dps=25) - 0.5688644810057831072783079 - 0.3515775842541429284870573j - """ - u = acb.__new__(acb) - acb_rsqrt_analytic((u).val, (s).val, analytic, getprec()) - return u - - def exp(s): - r""" - Exponential function `\exp(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).exp(), dps=25) - -1.131204383756813638431255 + 2.471726672004818927616931j - """ - u = acb.__new__(acb) - acb_exp((u).val, (s).val, getprec()) - return u - - def exp_pi_i(s): - r""" - Exponential function of modified argument `\exp(\pi i s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).exp_pi_i(), dps=25) - -0.001867442731707988814430213 - >>> showgood(lambda: acb(1.5,2.5).exp_pi_i(), dps=25) - -0.0003882032039267662472325299j - >>> showgood(lambda: acb(1.25,2.25).exp_pi_i(), dps=25) - -0.0006020578259597635239581705 - 0.0006020578259597635239581705j - """ - u = acb.__new__(acb) - acb_exp_pi_i((u).val, (s).val, getprec()) - return u - - def expm1(s): - r""" - Exponential function `\exp(s)-1`, computed accurately for small *s*. - - >>> from flint import showgood - >>> showgood(lambda: acb("1e-10000").expm1(), dps=25) - 1.000000000000000000000000e-10000 - """ - u = acb.__new__(acb) - acb_expm1((u).val, (s).val, getprec()) - return u - - def sin(s): - r""" - Sine function `\sin(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).sin(), dps=25) - 3.165778513216168146740735 + 1.959601041421605897070352j - """ - u = acb.__new__(acb) - acb_sin((u).val, (s).val, getprec()) - return u - - def cos(s): - r""" - Cosine function `\cos(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).cos(), dps=25) - 2.032723007019665529436343 - 3.051897799151800057512116j - """ - u = acb.__new__(acb) - acb_cos((u).val, (s).val, getprec()) - return u - - def sin_cos(s): - r""" - Computes `\sin(s)` and `\cos(s)` simultaneously. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).sin_cos(), dps=15) - (3.16577851321617 + 1.95960104142161j, 2.03272300701967 - 3.05189779915180j) - """ - u = acb.__new__(acb) - v = acb.__new__(acb) - acb_sin_cos((u).val, (v).val, (s).val, getprec()) - return u, v - - def tan(s): - r""" - Tangent function `\tan(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).tan(), dps=25) - 0.03381282607989669028437056 + 1.014793616146633568117054j - """ - u = acb.__new__(acb) - acb_tan((u).val, (s).val, getprec()) - return u - - def cot(s): - r""" - Cotangent function `\cot(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).cot(), dps=25) - 0.03279775553375259406276455 - 0.9843292264581910294718882j - """ - u = acb.__new__(acb) - acb_cot((u).val, (s).val, getprec()) - return u - - def sin_pi(s): - r""" - Sine function `\sin(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).sin_pi(), dps=25) - -267.7448940410165142571174j - """ - u = acb.__new__(acb) - acb_sin_pi((u).val, (s).val, getprec()) - return u - - def cos_pi(s): - r""" - Cosine function `\cos(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).cos_pi(), dps=25) - -267.7467614837482222459319 - """ - u = acb.__new__(acb) - acb_cos_pi((u).val, (s).val, getprec()) - return u - - def sin_cos_pi(s): - r""" - Computes `\sin(\pi s)` and `\cos(\pi s)` simultaneously. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).sin_cos_pi(), dps=25) - (-267.7448940410165142571174j, -267.7467614837482222459319) - """ - u = acb.__new__(acb) - v = acb.__new__(acb) - acb_sin_cos_pi((u).val, (v).val, (s).val, getprec()) - return u, v - - def tan_pi(s): - r""" - Tangent function `\tan(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).tan_pi(), dps=25) - 0.9999930253396106106051072j - """ - u = acb.__new__(acb) - acb_tan_pi((u).val, (s).val, getprec()) - return u - - def cot_pi(s): - r""" - Cotangent function `\cot(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).cot_pi(), dps=25) - -1.000006974709035616233122j - """ - u = acb.__new__(acb) - acb_cot_pi((u).val, (s).val, getprec()) - return u - - def sec(s): - r""" - Secant function `\sec(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).sec(), dps=25) - -0.04167496441114427004834991 + 0.09061113719623759652966120j - """ - u = acb.__new__(acb) - acb_sec((u).val, (s).val, getprec()) - return u - - def csc(s): - r""" - Cosecant function `\sec(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).csc(), dps=25) - 0.09047320975320743980579048 + 0.04120098628857412646300981j - """ - u = acb.__new__(acb) - acb_csc((u).val, (s).val, getprec()) - return u - - def sinh(s): - r""" - Hyperbolic sine function `\sinh(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).sinh(), dps=25) - -3.590564589985779952012565 + 0.5309210862485198052670401j - """ - u = acb.__new__(acb) - acb_sinh((u).val, (s).val, getprec()) - return u - - def cosh(s): - r""" - Hyperbolic cosine function `\cosh(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).cosh(), dps=25) - -3.724545504915322565473971 + 0.5118225699873846088344638j - """ - u = acb.__new__(acb) - acb_cosh((u).val, (s).val, getprec()) - return u - - def sinh_cosh(s): - r""" - Computes `\sinh(s)` and `\cosh(s)` simultaneously. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).sinh_cosh(), dps=15) - (-0.489056259041294 + 1.40311925062204j, -0.642148124715520 + 1.06860742138278j) - """ - u = acb.__new__(acb) - v = acb.__new__(acb) - acb_sinh_cosh((u).val, (v).val, (s).val, getprec()) - return u, v - - def tanh(s): - r""" - Hyperbolic tangent function `\tanh(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).tanh(), dps=25) - 0.9653858790221331242784803 - 0.009884375038322493720314034j - """ - u = acb.__new__(acb) - acb_tanh((u).val, (s).val, getprec()) - return u - - def coth(s): - r""" - Hyperbolic cotangent function `\coth(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).coth(), dps=25) - 1.035746637764995396112759 + 0.01060478347033710175031690j - """ - u = acb.__new__(acb) - acb_coth((u).val, (s).val, getprec()) - return u - - def sech(s): - r""" - Hyperbolic secant function `\operatorname{sech}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).sech(), dps=25) - -0.2635129751583893096436042 - 0.03621163655876852087145690j - """ - u = acb.__new__(acb) - acb_sech((u).val, (s).val, getprec()) - return u - - def csch(s): - r""" - Hyperbolic cosecant function `\operatorname{csch}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).csch(), dps=25) - -0.2725486614629401995124985 - 0.04030057885689152187513248j - """ - u = acb.__new__(acb) - acb_csch((u).val, (s).val, getprec()) - return u - - def sinc(s): - r""" - Sinc function, `\operatorname{sinc}(x) = \sin(x)/x`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).sinc(), dps=25) - 0.4463290318402435457438585 - 2.753947027743647493993194j - """ - u = acb.__new__(acb) - acb_sinc((u).val, (s).val, getprec()) - return u - - def sinc_pi(s): - r""" - Normalized sinc function, `\operatorname{sinc}(\pi x) = \sin(\pi x)/(\pi x)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).sinc_pi(), dps=25) - 455.1212281938610260024088 + 303.4141521292406840016059j - """ - u = acb.__new__(acb) - acb_sinc_pi((u).val, (s).val, getprec()) - return u - - def rising(s, n): - """ - Rising factorial `(s)_n`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).rising(5), dps=25) - -540.0000000000000000000000 - 100.0000000000000000000000j - >>> showgood(lambda: acb(1,2).rising(2+3j), dps=25) - 0.3898076751098812033498554 - 0.01296289149274537721607465j - """ - u = acb.__new__(acb) - n = any_as_acb(n) - acb_rising((u).val, (s).val, (n).val, getprec()) - return u - - def rising2(s, ulong n): - """ - Computes the rising factorial `(s)_n` where *n* is an unsigned - integer, along with the first derivative with respect to `(s)_n`. - The current implementation does not use the gamma function, - so *n* should be moderate. - - >>> from flint import showgood - >>> showgood(lambda: acb(1,2).rising2(5), dps=25) - (-540.0000000000000000000000 - 100.0000000000000000000000j, -666.0000000000000000000000 + 420.0000000000000000000000j) - """ - u = acb.__new__(acb) - v = acb.__new__(acb) - acb_rising2_ui((u).val, (v).val, (s).val, n, getprec()) - return u, v - - def polylog(self, s): - r""" - Computes the polylogarithm `\operatorname{Li}_s(z)` where - the argument *z* is given by *self* and the order *s* is given - as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: acb(3).polylog(2), dps=25) - 2.320180423313098396406194 - 3.451392295223202661433821j - >>> showgood(lambda: acb(2,3).polylog(1+2j), dps=25) - -6.854984251829306907116775 + 7.375884252099214498443165j - """ - u = acb.__new__(acb) - s = any_as_acb(s) - acb_polylog((u).val, (s).val, (self).val, getprec()) - return u - - def erf(s): - r""" - Error function `\operatorname{erf}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).erf() - 1, dps=25) - -21.82946142761456838910309 + 8.687318271470163144428079j - >>> showgood(lambda: acb("77.7").erf() - 1, dps=25, maxdps=10000) - -7.929310690520378873143053e-2625 - """ - u = acb.__new__(acb) - acb_hypgeom_erf((u).val, (s).val, getprec()) - return u - - def modular_theta(z, tau, ulong r=0): - r""" - Computes the Jacobi theta functions `\theta_1(z,\tau)`, - `\theta_2(z,\tau)`, `\theta_3(z,\tau)`, `\theta_4(z,\tau)`, - returning all four values as a tuple. - We define the theta functions with a factor `\pi` for *z* included; - for example - `\theta_3(z,\tau) = 1 + 2 \sum_{n=1}^{\infty} q^{n^2} \cos(2n\pi z)`. - - >>> from flint import showgood - >>> for i in range(4): - ... showgood(lambda: acb(1+1j).modular_theta(1.25+3j)[i], dps=25) - ... - 1.820235910124989594900076 - 1.216251950154477951760042j - -1.220790267576967690128359 - 1.827055516791154669091679j - 0.9694430387796704100046143 - 0.03055696120816803328582847j - 1.030556961196006476576271 + 0.03055696120816803328582847j - """ - cdef acb_ptr T1, T2, T3, T4 - assert r <= 1000000 - tau = any_as_acb(tau) - t1 = acb.__new__(acb) - t2 = acb.__new__(acb) - t3 = acb.__new__(acb) - t4 = acb.__new__(acb) - if r == 0: - acb_modular_theta((t1).val, (t2).val, - (t3).val, (t4).val, - (z).val, (tau).val, getprec()) - else: - T1 = _acb_vec_init(r + 1) - T2 = _acb_vec_init(r + 2) - T3 = _acb_vec_init(r + 3) - T4 = _acb_vec_init(r + 4) - acb_modular_theta_jet(T1, T2, T3, T4, - (z).val, (tau).val, r + 1, getprec()) - acb_set((t1).val, T1 + r) - acb_set((t2).val, T2 + r) - acb_set((t3).val, T3 + r) - acb_set((t4).val, T4 + r) - c = arb.fac_ui(r) - t1 *= c - t2 *= c - t3 *= c - t4 *= c - _acb_vec_clear(T1, r + 1) - _acb_vec_clear(T2, r + 1) - _acb_vec_clear(T3, r + 1) - _acb_vec_clear(T4, r + 1) - return (t1, t2, t3, t4) - - def modular_eta(tau): - r""" - Dedekind eta function `\eta(\tau)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1+1j).modular_eta(), dps=25) - 0.7420487758365647263392722 + 0.1988313702299107190516142j - """ - u = acb.__new__(acb) - acb_modular_eta((u).val, (tau).val, getprec()) - return u - - def modular_j(tau): - r""" - Modular *j*-invariant `j(\tau)`. - - >>> from flint import showgood - >>> showgood(lambda: (1 + acb(-163).sqrt()/2).modular_j(), dps=25) - 262537412640769488.0000000 - >>> showgood(lambda: acb(3.25+100j).modular_j() - 744, dps=25, maxdps=2000) - -3.817428033843319485125773e-539 - 7.503618895582604309279721e+272j - """ - u = acb.__new__(acb) - acb_modular_j((u).val, (tau).val, getprec()) - return u - - def modular_lambda(tau): - r""" - Modular lambda function `\lambda(\tau)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(0.25+5j).modular_lambda(), dps=25) - 1.704995415668039343330405e-6 + 1.704992508662079437786598e-6j - """ - u = acb.__new__(acb) - acb_modular_lambda((u).val, (tau).val, getprec()) - return u - - def modular_delta(tau): - r""" - Modular discriminant `\Delta(\tau)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(0.25+5j).modular_delta(), dps=25) - 1.237896015010281684100435e-26 + 2.271101068324093838679275e-14j - """ - u = acb.__new__(acb) - acb_modular_delta((u).val, (tau).val, getprec()) - return u - - def elliptic_k(m): - """ - Complete elliptic integral of the first kind `K(m)`. - - >>> from flint import showgood - >>> showgood(lambda: 2 * acb(0).elliptic_k(), dps=25) - 3.141592653589793238462643 - >>> showgood(lambda: acb(100+50j).elliptic_k(), dps=25) - 0.2052037361984861505113972 + 0.3158446040520529200980591j - >>> showgood(lambda: (1 - acb("1e-100")).elliptic_k(), dps=25) - 116.5155490108221748197340 - """ - u = acb.__new__(acb) - acb_modular_elliptic_k((u).val, (m).val, getprec()) - return u - - def elliptic_e(m): - """ - Complete elliptic integral of the second kind `E(m)`. - >>> from flint import showgood - >>> showgood(lambda: 2 * acb(0).elliptic_e(), dps=25) - 3.141592653589793238462643 - >>> showgood(lambda: acb(100+50j).elliptic_e(), dps=25) - 2.537235535915583230880553 - 10.10997759792420947130321j - >>> showgood(lambda: (1 - acb("1e-100")).elliptic_e(), dps=25) - 1.000000000000000000000000 - - """ - u = acb.__new__(acb) - acb_modular_elliptic_e((u).val, (m).val, getprec()) - return u - - def unique_fmpz(self): - r""" - If *self* represents exactly one integer, returns this value - as an *fmpz*; otherwise returns *None*. - - >>> acb("5 +/- 0.1").unique_fmpz() - 5 - >>> acb("5 +/- 0.9", "10 +/- 11").unique_fmpz() - 5 - >>> acb("5 +/- 0.9", 11).unique_fmpz() - >>> - >>> acb("5.1 +/- 0.9").unique_fmpz() - >>> - - """ - u = fmpz.__new__(fmpz) - if acb_get_unique_fmpz((u).val, self.val): - return u - else: - return None - - def gamma_upper(self, s, int regularized=0): - r""" - Upper incomplete gamma function `\Gamma(s,z)`. The argument *z* - is given by *self* and the order *s* is passed as an extra parameter. - Optionally the regularized version `Q(s,z)` can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).gamma_upper(1+2j), dps=25) - 0.02614303924198793235765248 - 0.0007536537278463329391666679j - >>> showgood(lambda: acb(2+3j).gamma_upper(1+2j, regularized=True), dps=25) - 0.1685897763996036749499208 - 0.02694171301624093921683609j - """ - s = any_as_acb(s) - u = acb.__new__(acb) - acb_hypgeom_gamma_upper((u).val, (s).val, (self).val, regularized, getprec()) - return u - - def gamma_lower(self, s, int regularized=0): - r""" - Lower incomplete gamma function `\gamma(s,z)`. The argument *z* - is given by *self* and the order *s* is passed as an extra parameter. - Optionally the regularized versions `P(s,z)` and - `\gamma^{*}(s,z) = z^{-s} P(s,z)` can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).gamma_lower(2.5), dps=25) - 1.646077010134876664349297 + 1.140585862703100904414519j - >>> showgood(lambda: acb(2+3j).gamma_lower(2.5, regularized=1), dps=25) - 1.238266003780709160156983 + 0.8580088838385611055576971j - >>> showgood(lambda: acb(2+3j).gamma_lower(2.5, regularized=2), dps=25) - -0.01687942194354244633506487 - 0.05864800341005793099108467j - """ - s = any_as_acb(s) - u = acb.__new__(acb) - acb_hypgeom_gamma_lower((u).val, (s).val, (self).val, regularized, getprec()) - return u - - def beta_lower(self, a, b, int regularized=0): - r""" - Lower incomplete beta function `B(a,b;z)`. The argument *z* - is given by *self* and the parameters *a* and *b* are passed - as extra function arguments. - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(2,3).beta_lower(1, 2.5), dps=25) - 0.2650137734913866999568502 - 7.111836702381954625752124j - >>> showgood(lambda: acb(2,3).beta_lower(1, 2.5, regularized=True), dps=25) - 0.6625344337284667498921254 - 17.77959175595488656438031j - """ - a = any_as_acb(a) - b = any_as_acb(b) - u = acb.__new__(acb) - acb_hypgeom_beta_lower((u).val, (a).val, (b).val, (self).val, regularized, getprec()) - return u - - def expint(self, s): - r""" - Generalized exponential integral `E_s(z)`. The argument *z* - is given by *self* and the order *s* is passed as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).expint(1+2j), dps=25) - -0.01442661495527080336037156 + 0.01942348372986687164972794j - """ - s = any_as_acb(s) - u = acb.__new__(acb) - acb_hypgeom_expint((u).val, (s).val, (self).val, getprec()) - return u - - def erfc(s): - r""" - Complementary error function `\operatorname{erfc}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb("77.7").erfc(), dps=25) - 7.929310690520378873143053e-2625 - """ - u = acb.__new__(acb) - acb_hypgeom_erfc((u).val, (s).val, getprec()) - return u - - def erfi(s): - r""" - Imaginary error function `\operatorname{erfi}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).erfi(), dps=25) - 1.524307422708669699360547e+42 - """ - u = acb.__new__(acb) - acb_hypgeom_erfi((u).val, (s).val, getprec()) - return u - - def rel_accuracy_bits(self): - return acb_rel_accuracy_bits(self.val) - - def rel_one_accuracy_bits(self): - return acb_rel_one_accuracy_bits(self.val) - - def bits(self): - r"""Returns maximum of :meth:`.arb.bits` called on real and imaginary part. - - >>> acb("2047/2048").bits() - 11 - """ - return acb_bits(self.val) - - def ei(s): - r""" - Exponential integral `\operatorname{Ei}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).ei(), dps=25) - 2492.228976241877759138440 - """ - u = acb.__new__(acb) - acb_hypgeom_ei((u).val, (s).val, getprec()) - return u - - def si(s): - r""" - Sine integral `\operatorname{Si}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).si(), dps=25) - 1.658347594218874049330972 - """ - u = acb.__new__(acb) - acb_hypgeom_si((u).val, (s).val, getprec()) - return u - - def ci(s): - r""" - Cosine integral `\operatorname{Ci}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).ci(), dps=25) - -0.04545643300445537263453283 - """ - u = acb.__new__(acb) - acb_hypgeom_ci((u).val, (s).val, getprec()) - return u - - def shi(s): - r""" - Hyperbolic sine integral `\operatorname{Shi}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).shi(), dps=25) - 1246.114490199423344411882 - """ - u = acb.__new__(acb) - acb_hypgeom_shi((u).val, (s).val, getprec()) - return u - - def chi(s): - r""" - Hyperbolic cosine integral `\operatorname{Chi}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).chi(), dps=25) - 1246.114486042454414726558 - """ - u = acb.__new__(acb) - acb_hypgeom_chi((u).val, (s).val, getprec()) - return u - - def li(s, bint offset=False): - r""" - Logarithmic integral `\operatorname{li}(s)`, optionally - the offset logarithmic integral - `\operatorname{Li}(s) = \operatorname{li}(s) - \operatorname{li}(2)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(10).li(), dps=25) - 6.165599504787297937522982 - >>> showgood(lambda: acb(10).li(offset=True), dps=25) - 5.120435724669805152678393 - """ - u = acb.__new__(acb) - acb_hypgeom_li((u).val, (s).val, offset, getprec()) - return u - - def hypgeom_2f1(self, a, b, c, bint regularized=False, bint ab=False, bint ac=False, bc=False, abc=False): - r""" - The hypergeometric function `{}_2F_1(a,b,c,z)` where the argument *z* - is given by *self* - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(5).hypgeom_2f1(1,2,3), dps=25) - -0.5109035488895912495067571 - 0.2513274122871834590770115j - >>> showgood(lambda: acb(5).hypgeom_2f1(1,2,3,regularized=True), dps=25) - -0.2554517744447956247533786 - 0.1256637061435917295385057j - - The flags *ab*, *ac*, *bc*, *abc* can be used to specify whether the - parameter differences `a-b`, `a-c`, `b-c` and `a+b-c` represent - exact integers, even if the input intervals are inexact. - If the parameters are exact, these flags are not needed. - - >>> from flint import arb - >>> from flint import showgood - >>> showgood(lambda: acb("11/10").hypgeom_2f1(arb(2).sqrt(), 0.5, arb(2).sqrt()+1.5, abc=True), dps=25) - 1.801782659480054173351004 - 0.3114019850045849100659641j - >>> showgood(lambda: acb("11/10").hypgeom_2f1(arb(2).sqrt(), 0.5, arb(2).sqrt()+1.5), dps=25) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - """ - cdef int flags - a = any_as_acb(a) - b = any_as_acb(b) - c = any_as_acb(c) - u = acb.__new__(acb) - flags = 0 - if regularized: - flags |= 1 - if ab: - flags |= 2 - if ac: - flags |= 4 - if bc: - flags |= 8 - if abc: - flags |= 16 - acb_hypgeom_2f1((u).val, (a).val, (b).val, (c).val, - (self).val, flags, getprec()) - return u - - def chebyshev_t(s, n): - r""" - Chebyshev function of the first kind `T_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).chebyshev_t(3), dps=25) - -0.8518518518518518518518519 - """ - v = acb.__new__(acb) - n = any_as_acb(n) - acb_hypgeom_chebyshev_t((v).val, (n).val, (s).val, getprec()) - return v - - def chebyshev_u(s, n): - r""" - Chebyshev function of the second kind `U_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).chebyshev_u(3), dps=25) - -1.037037037037037037037037 - """ - v = acb.__new__(acb) - n = any_as_acb(n) - acb_hypgeom_chebyshev_u((v).val, (n).val, (s).val, getprec()) - return v - - def jacobi_p(s, n, a, b): - r""" - Jacobi polynomial (or Jacobi function) `P_n^{a,b}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).jacobi_p(5, 0.25, 0.5), dps=25) - 0.4131944444444444444444444 - """ - v = acb.__new__(acb) - n = any_as_acb(n) - a = any_as_acb(a) - b = any_as_acb(b) - acb_hypgeom_jacobi_p((v).val, (n).val, (a).val, (b).val, (s).val, getprec()) - return v - - def gegenbauer_c(s, n, m): - r""" - Gegenbauer function `C_n^{m}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).gegenbauer_c(5, 0.25), dps=25) - 0.1321855709876543209876543 - """ - v = acb.__new__(acb) - n = any_as_acb(n) - m = any_as_acb(m) - acb_hypgeom_gegenbauer_c((v).val, (n).val, (m).val, (s).val, getprec()) - return v - - def laguerre_l(s, n, m=0): - r""" - Laguerre function `L_n^{m}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).laguerre_l(5, 0.25), dps=25) - 0.03871323490012002743484225 - """ - v = acb.__new__(acb) - n = any_as_acb(n) - m = any_as_acb(m) - acb_hypgeom_laguerre_l((v).val, (n).val, (m).val, (s).val, getprec()) - return v - - def hermite_h(s, n): - r""" - Hermite function `H_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).hermite_h(5), dps=25) - 34.20576131687242798353909 - """ - v = acb.__new__(acb) - n = any_as_acb(n) - acb_hypgeom_hermite_h((v).val, (n).val, (s).val, getprec()) - return v - - def legendre_p(s, n, m=0, int type=2): - r""" - Legendre function of the first kind `P_n^m(z)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).legendre_p(5), dps=25) - 0.3333333333333333333333333 - >>> showgood(lambda: (acb(1)/3).legendre_p(5, 1.5), dps=25) - -2.372124991643971726805456 - >>> showgood(lambda: (acb(3)).legendre_p(5, 1.5, type=2), dps=25) - -12091.31397811720689120900 - 12091.31397811720689120900j - >>> showgood(lambda: (acb(3)).legendre_p(5, 1.5, type=3), dps=25) - 17099.70021476473458984981 - - The optional parameter *type* can be 2 or 3, and selects between - two different branch cut conventions (see *Mathematica* and *mpmath*). - """ - v = acb.__new__(acb) - n = any_as_acb(n) - m = any_as_acb(m) - if type != 2 and type != 3: - raise ValueError("type must be 2 or 3") - type -= 2 - acb_hypgeom_legendre_p((v).val, (n).val, (m).val, (s).val, type, getprec()) - return v - - def legendre_q(s, n, m=0, int type=2): - r""" - Legendre function of the second kind `Q_n^m(z)`. - - >>> from flint import showgood - >>> showgood(lambda: (acb(1)/3).legendre_q(5), dps=25) - 0.1655245300933242182362054 - >>> showgood(lambda: (acb(1)/3).legendre_q(5, 1.5), dps=25) - -6.059967350218583975575616 - >>> showgood(lambda: (acb(3)).legendre_q(5, 1.5, type=2), dps=25) - -18992.99179585607569083751 + 18992.99179585607569083751j - >>> showgood(lambda: (acb(3)).legendre_q(5, 1.5, type=3), dps=25) - -0.0003010942389043591251820434j - - The optional parameter *type* can be 2 or 3, and selects between - two different branch cut conventions (see *Mathematica* and *mpmath*). - """ - v = acb.__new__(acb) - n = any_as_acb(n) - m = any_as_acb(m) - if type != 2 and type != 3: - raise ValueError("type must be 2 or 3") - type -= 2 - acb_hypgeom_legendre_q((v).val, (n).val, (m).val, (s).val, type, getprec()) - return v - - @staticmethod - def spherical_y(long n, long m, theta, phi): - r""" - Spherical harmonic `Y_n^m(\theta, \phi)`. - The present implementation only supports integer *n* and *m*. - - >>> from flint import showgood - >>> showgood(lambda: acb.spherical_y(5, 3, 0.25, 0.75), dps=25) - 0.02451377199072374024317003 - 0.03036343496553117039110087j - """ - v = acb.__new__(acb) - theta = any_as_acb(theta) - phi = any_as_acb(phi) - acb_hypgeom_spherical_y((v).val, n, m, (theta).val, (phi).val, getprec()) - return v - - def airy_ai(s, int derivative=0): - r""" - Airy function `\operatorname{Ai}(s)`, or - `\operatorname{Ai}'(s)` if *derivative* is 1. - - >>> from flint import showgood - >>> showgood(lambda: acb(-1+1j).airy_ai(), dps=25) - 0.8221174265552725939610246 - 0.1199663426644243438939006j - >>> showgood(lambda: acb(-1+1j).airy_ai(derivative=1), dps=25) - -0.3790604792268334962367164 - 0.6045001308622460716372591j - """ - u = acb.__new__(acb) - if derivative == 0: - acb_hypgeom_airy((u).val, NULL, NULL, NULL, (s).val, getprec()) - elif derivative == 1: - acb_hypgeom_airy(NULL, (u).val, NULL, NULL, (s).val, getprec()) - else: - raise ValueError("derivative must be 0 or 1") - return u - - def airy_bi(s, int derivative=0): - r""" - Airy function `\operatorname{Bi}(s)`, or - `\operatorname{Bi}'(s)` if *derivative* is 1. - - >>> from flint import showgood - >>> showgood(lambda: acb(-1+1j).airy_bi(), dps=25) - 0.2142904015348735739780868 + 0.6739169237227052095951775j - >>> showgood(lambda: acb(-1+1j).airy_bi(derivative=1), dps=25) - 0.8344734885227826369040951 - 0.3465260632668285285537957j - """ - u = acb.__new__(acb) - if derivative == 0: - acb_hypgeom_airy(NULL, NULL, (u).val, NULL, (s).val, getprec()) - elif derivative == 1: - acb_hypgeom_airy(NULL, NULL, NULL, (u).val, (s).val, getprec()) - else: - raise ValueError("derivative must be 0 or 1") - return u - - def airy(s): - r""" - Computes the Airy function values `\operatorname{Ai}(s)`, - `\operatorname{Ai}'(s)`, `\operatorname{Bi}(s)`, - `\operatorname{Bi}'(s)` simultaneously, returning a tuple. - - >>> from flint import showgood - >>> showgood(lambda: acb(-1+1j).airy(), dps=5) - (0.82212 - 0.11997j, -0.37906 - 0.60450j, 0.21429 + 0.67392j, 0.83447 - 0.34653j) - """ - u = acb.__new__(acb) - v = acb.__new__(acb) - w = acb.__new__(acb) - z = acb.__new__(acb) - acb_hypgeom_airy((u).val, (v).val, - (w).val, (z).val, (s).val, getprec()) - return u, v, w, z - - def lambertw(s, branch=0, bint left=False, bint middle=False): - r""" - Lambert *W* function, `W_k(s)` where *k* is given by *branch*. - - >>> from flint import showgood - >>> showgood(lambda: acb(1).lambertw(), dps=25) - 0.5671432904097838729999687 - >>> showgood(lambda: acb(1).lambertw(-1), dps=25) - -1.533913319793574507919741 - 4.375185153061898385470907j - >>> showgood(lambda: acb(1).lambertw(-2), dps=25) - -2.401585104868002884174140 - 10.77629951611507089849710j - - The branch cuts follow Corless et al. by default. This function - allows selecting alternative branch cuts in order to support - continuous analytic continuation on complex intervals. - - If *left* is set, computes `W_{\mathrm{left}|k}(z)` - which corresponds to `W_k(z)` in the upper - half plane and `W_{k+1}(z)` in the lower half plane, connected continuously - to the left of the branch points. - In other words, the branch cut on `(-\infty,0)` is rotated counterclockwise - to `(0,+\infty)`. - (For `k = -1` and `k = 0`, there is also a branch cut on `(-1/e,0)`, - continuous from below instead of from above to maintain counterclockwise - continuity.) - - If *middle* is set, computes - `W_{\mathrm{middle}}(z)` which corresponds to - `W_{-1}(z)` in the upper half plane and `W_{1}(z)` in the lower half - plane, connected continuously through `(-1/e,0)` with branch cuts - on `(-\infty,-1/e)` and `(0,+\infty)`. `W_{\mathrm{middle}}(z)` extends the - real analytic function `W_{-1}(x)` defined on `(-1/e,0)` to a complex - analytic function, whereas the standard branch `W_{-1}(z)` has a branch - cut along the real segment. - - >>> acb(-5,"+/- 1e-20").lambertw() - [0.844844605432170 +/- 6.18e-16] + [+/- 1.98]j - >>> acb(-5,"+/- 1e-20").lambertw(left=True) - [0.844844605432170 +/- 7.85e-16] + [1.97500875488903 +/- 4.05e-15]j - >>> acb(-5,"+/- 1e-20").lambertw(-1, left=True) - [0.844844605432170 +/- 7.85e-16] + [-1.97500875488903 +/- 4.05e-15]j - >>> acb(-0.25,"+/- 1e-20").lambertw(middle=True) - [-2.15329236411035 +/- 1.48e-15] + [+/- 4.87e-16]j - """ - cdef int flags - u = acb.__new__(acb) - flags = 0 - if middle: - flags = 4 - branch = -1 - elif left: - flags = 2 - k = any_as_fmpz(branch) - acb_lambertw((u).val, (s).val, (k).val, flags, getprec()) - return u - - def real_abs(s, bint analytic=False): - r""" - Absolute value of a real variable, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> f = lambda z, a: (z**3).real_abs(analytic=a) - >>> from flint import showgood - >>> showgood(lambda: acb.integral(f, -1, 1), dps=25) - 0.5000000000000000000000000 - """ - u = acb.__new__(acb) - acb_real_abs((u).val, (s).val, analytic, getprec()) - return u - - def real_sgn(s, bint analytic=False): - r""" - Sign function of a real variable, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> acb(-5+2j).real_sgn() - -1.00000000000000 - >>> acb(0).real_sgn() - 0 - >>> acb(0).real_sgn(analytic=True) - nan + nanj - """ - u = acb.__new__(acb) - acb_real_sgn((u).val, (s).val, analytic, getprec()) - return u - - def real_heaviside(s, bint analytic=False): - r""" - Heaviside step function of a real variable, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> acb(-5+2j).real_heaviside(analytic=True) - 0 - >>> acb(5+2j).real_heaviside(analytic=True) - 1.00000000000000 - >>> acb(0).real_heaviside(analytic=True) - nan + nanj - >>> acb(0).real_heaviside() - 0.500000000000000 - """ - u = acb.__new__(acb) - acb_real_heaviside((u).val, (s).val, analytic, getprec()) - return u - - def real_floor(s, bint analytic=False): - r""" - Floor function of a real variable, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> from flint import showgood - >>> showgood(lambda: acb.integral(lambda x, a: x.real_floor(analytic=a), 0, 100), dps=15) - 4950.00000000000 - """ - u = acb.__new__(acb) - acb_real_floor((u).val, (s).val, analytic, getprec()) - return u - - def real_ceil(s, bint analytic=False): - r""" - Ceiling function of a real variable, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> from flint import showgood - >>> showgood(lambda: acb.integral(lambda x, a: x.real_ceil(analytic=a), 0, 100), dps=15) - 5050.00000000000 - """ - u = acb.__new__(acb) - acb_real_ceil((u).val, (s).val, analytic, getprec()) - return u - - def real_max(s, t, bint analytic=False): - r""" - Maximum value of two real variables, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> f = lambda x, a: x.sin().real_max(x.cos(), analytic=a) - >>> from flint import showgood - >>> showgood(lambda: acb.integral(f, 0, acb.pi())) - 2.41421356237310 - """ - u = acb.__new__(acb) - acb_real_max((u).val, (s).val, (t).val, analytic, getprec()) - return u - - def real_min(s, t, bint analytic=False): - r""" - Minimum value of two real variables, extended to a piecewise complex - analytic function. This function is useful for integration. - - >>> f = lambda x, a: x.sin().real_min(x.cos(), analytic=a) - >>> from flint import showgood - >>> showgood(lambda: acb.integral(f, 0, acb.pi())) - -0.414213562373095 - """ - u = acb.__new__(acb) - acb_real_min((u).val, (s).val, (t).val, analytic, getprec()) - return u - - def real_sqrt(s, bint analytic=False): - r""" - Square root of a real variable assumed to be nonnegative, extended - to a piecewise complex analytic function. This function is - useful for integration. - - >>> acb.integral(lambda x, a: x.sqrt(analytic=a), 0, 1) - [0.6666666666667 +/- 4.19e-14] + [+/- 1.12e-16]j - >>> acb.integral(lambda x, a: x.real_sqrt(analytic=a), 0, 1) - [0.6666666666667 +/- 4.19e-14] - """ - u = acb.__new__(acb) - acb_real_sqrtpos((u).val, (s).val, analytic, getprec()) - return u - - @staticmethod - def stieltjes(n, a=1): - r""" - Generalized Stieltjes constant `\gamma_n(a)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.stieltjes(1), dps=25) - -0.07281584548367672486058638 - >>> showgood(lambda: acb.stieltjes(10**10), dps=25) - 7.588362123713105194822403e+12397849705 - >>> showgood(lambda: acb.stieltjes(1000, 2+3j), dps=25) - -1.206122870741999199264747e+494 - 1.389205283963836265123849e+494j - """ - cdef acb u - n = fmpz(n) - if n < 0: - raise ValueError("n must be nonnegative") - a = acb(a) - u = acb.__new__(acb) - acb_dirichlet_stieltjes(u.val, (n).val, (a).val, getprec()) - return u - - def bernoulli_poly(s, ulong n): - """ - Returns the value of the Bernoulli polynomial `B_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(0.25+0.25j).bernoulli_poly(5), dps=25) - -0.05859375000000000000000000 + 0.006510416666666666666666667j - """ - u = acb.__new__(acb) - acb_bernoulli_poly_ui((u).val, n, s.val, getprec()) - return u - - @staticmethod - def dft(vec, bint inverse=False): - r""" - Returns the discrete Fourier transform (DFT) of a given - iterable *vec*. The output is a list of *acb* entries. - If *inverse* is True, computes the inverse transform instead. - - >>> for c in acb.dft(acb.dft(range(1,12)), inverse=True): - ... print(c) - ... - [1.000000000000 +/- 1.06e-13] + [+/- 8.66e-14]j - [2.000000000000 +/- 1.25e-13] + [+/- 1.17e-13]j - [3.000000000000 +/- 1.29e-13] + [+/- 1.21e-13]j - [4.000000000000 +/- 1.34e-13] + [+/- 1.22e-13]j - [5.000000000000 +/- 1.40e-13] + [+/- 1.24e-13]j - [6.000000000000 +/- 1.50e-13] + [+/- 1.26e-13]j - [7.000000000000 +/- 1.43e-13] + [+/- 1.26e-13]j - [8.000000000000 +/- 1.47e-13] + [+/- 1.23e-13]j - [9.000000000000 +/- 1.47e-13] + [+/- 1.22e-13]j - [10.00000000000 +/- 1.50e-13] + [+/- 1.20e-13]j - [11.000000000000 +/- 1.43e-13] + [+/- 1.22e-13]j - >>> sum(acb.dft(acb.dft(range(1,10001)), inverse=True)).contains(50005000) - True - - """ - cdef long i, n - cdef acb_ptr w - cdef list v - v = [acb(t) for t in vec] - n = len(v) - if n == 0: - return v - w = libc.stdlib.malloc(n * cython.sizeof(acb_struct)) - for i in range(n): - w[i] = ((v[i])).val[0] - if inverse: - acb_dft_inverse(w, w, n, getprec()) - else: - acb_dft(w, w, n, getprec()) - for i in range(n): - ((v[i])).val[0] = w[i] - libc.stdlib.free(w) - return v - - def fresnel_s(s, bint normalized=True): - r""" - Fresnel sine integral `S(s)`, optionally not normalized. - - >>> from flint import showgood - >>> showgood(lambda: acb(3).fresnel_s(), dps=25) - 0.4963129989673750360976123 - >>> showgood(lambda: acb(3).fresnel_s(normalized=False), dps=25) - 0.7735625268937690171497722 - """ - u = acb.__new__(acb) - acb_hypgeom_fresnel((u).val, NULL, (s).val, normalized, getprec()) - return u - - def fresnel_c(s, bint normalized=True): - r""" - Fresnel cosine integral `C(s)`, optionally not normalized. - - >>> from flint import showgood - >>> showgood(lambda: acb(3).fresnel_c(), dps=25) - 0.6057207892976856295561611 - >>> showgood(lambda: acb(3).fresnel_c(normalized=False), dps=25) - 0.7028635577302687301744099 - """ - u = acb.__new__(acb) - acb_hypgeom_fresnel(NULL, (u).val, (s).val, normalized, getprec()) - return u - - def log_sin_pi(s): - r""" - Logarithmic sine function with analytic continuation defined to be - consistent with the functional equation of the log gamma function. - - >>> from flint import showgood - >>> showgood(lambda: acb(5+2j).log_sin_pi(), dps=25) - 5.590034639271204166020651 - 14.13716694115406957308190j - >>> showgood(lambda: acb(5+2j).sin_pi().log(), dps=25) - 5.590034639271204166020651 - 1.570796326794896619231322j - """ - u = acb.__new__(acb) - acb_log_sin_pi((u).val, (s).val, getprec()) - return u - - @staticmethod - def elliptic_rf(x, y, z): - r""" - Carlson incomplete elliptic integral `R_F(x,y,z)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_rf(1, 2+3j, 3+4j), dps=25) - 0.5577655465453921610327459 - 0.2202042457195556054465308j - """ - x = any_as_acb(x) - y = any_as_acb(y) - z = any_as_acb(z) - u = acb.__new__(acb) - acb_elliptic_rf((u).val, (x).val, (y).val, (z).val, 0, getprec()) - return u - - @staticmethod - def elliptic_rc(x, y): - r""" - Carlson incomplete elliptic integral `R_C(x,y)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_rc(1, 2+3j), dps=25) - 0.5952169239306156198937085 - 0.2387981909090509407085918j - """ - x = any_as_acb(x) - y = any_as_acb(y) - u = acb.__new__(acb) - acb_elliptic_rf((u).val, (x).val, (y).val, (y).val, 0, getprec()) - return u - - @staticmethod - def elliptic_rj(x, y, z, p): - r""" - Carlson incomplete elliptic integral `R_J(x,y,z,p)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_rj(1, 2, 1+2j, 2+3j), dps=25) - 0.1604659632144333057202530 - 0.2502751672723324201692394j - """ - x = any_as_acb(x) - y = any_as_acb(y) - z = any_as_acb(z) - p = any_as_acb(p) - u = acb.__new__(acb) - acb_elliptic_rj((u).val, (x).val, (y).val, (z).val, (p).val, 0, getprec()) - return u - - @staticmethod - def elliptic_rd(x, y, z): - r""" - Carlson incomplete elliptic integral `R_D(x,y,z)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_rd(1, 2, 1+2j), dps=25) - 0.2043722510302629773408686 - 0.3559745898273715996616328j - """ - x = any_as_acb(x) - y = any_as_acb(y) - z = any_as_acb(z) - u = acb.__new__(acb) - acb_elliptic_rj((u).val, (x).val, (y).val, (z).val, (z).val, 0, getprec()) - return u - - @staticmethod - def elliptic_rg(x, y, z): - r""" - Carlson incomplete elliptic integral `R_G(x,y,z)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_rg(1, 2, 1+2j), dps=25) - 1.206557168056722980475052 + 0.2752176688707739710008275j - """ - x = any_as_acb(x) - y = any_as_acb(y) - z = any_as_acb(z) - u = acb.__new__(acb) - acb_elliptic_rg((u).val, (x).val, (y).val, (z).val, 0, getprec()) - return u - - @staticmethod - def elliptic_f(phi, m, bint pi=False): - r""" - Incomplete elliptic integral `F(\phi,m)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_f(2, 0.75), dps=25) - 2.952569673655779502336268 - >>> showgood(lambda: acb.elliptic_f(2, 0.75, pi=True), dps=25) - 8.626062589998572941754700 - """ - phi = any_as_acb(phi) - m = any_as_acb(m) - u = acb.__new__(acb) - acb_elliptic_f((u).val, (phi).val, (m).val, pi, getprec()) - return u - - @staticmethod - def elliptic_e_inc(phi, m, bint pi=False): - r""" - Incomplete elliptic integral `E(\phi,m)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_e_inc(2, 0.75), dps=25) - 1.443433069099461566497882 - >>> showgood(lambda: acb.elliptic_e_inc(2, 0.75, pi=True), dps=25) - 4.844224110273838099214252 - """ - phi = any_as_acb(phi) - m = any_as_acb(m) - u = acb.__new__(acb) - acb_elliptic_e_inc((u).val, (phi).val, (m).val, pi, getprec()) - return u - - @staticmethod - def elliptic_pi(n, m): - r""" - Complete elliptic integral `\Pi(n,m)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_pi(0.25, 0.125), dps=25) - 1.879349451879603826415650 - """ - n = any_as_acb(n) - m = any_as_acb(m) - u = acb.__new__(acb) - acb_elliptic_pi((u).val, (n).val, (m).val, getprec()) - return u - - @staticmethod - def elliptic_pi_inc(n, phi, m, bint pi=False): - r""" - Incomplete elliptic integral `\Pi(n,\phi,m)`. - - >>> from flint import showgood - >>> showgood(lambda: acb.elliptic_pi_inc(0.25, 0.5, 0.125), dps=25) - 0.5128718023282086251399279 - >>> showgood(lambda: acb.elliptic_pi_inc(0.25, 0.5, 0.125, pi=True), dps=25) - 1.879349451879603826415650 - """ - n = any_as_acb(n) - phi = any_as_acb(phi) - m = any_as_acb(m) - u = acb.__new__(acb) - acb_elliptic_pi_inc((u).val, (n).val, (phi).val, (m).val, pi, getprec()) - return u - - def elliptic_p(self, tau): - r""" - Weierstrass elliptic function `\wp(z, \tau)` where *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb("1/3","1/5").elliptic_p(1j), dps=25) - 3.686380646078879780287811 - 4.591498371497259422829963j - >>> showgood(lambda: acb("1/3","6/5").elliptic_p(1j), dps=25) - 3.686380646078879780287811 - 4.591498371497259422829963j - """ - tau = any_as_acb(tau) - u = acb.__new__(acb) - acb_elliptic_p((u).val, (self).val, (tau).val, getprec()) - return u - - def elliptic_zeta(self, tau): - r""" - Weierstrass elliptic function `\zeta(z, \tau)` where *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb("1/3","1/5").elliptic_zeta(1j), dps=25) - 2.219680339508418716159086 - 1.504947925755241700681002j - """ - tau = any_as_acb(tau) - u = acb.__new__(acb) - acb_elliptic_zeta((u).val, (self).val, (tau).val, getprec()) - return u - - def elliptic_sigma(self, tau): - r""" - Weierstrass elliptic function `\sigma(z, \tau)` where *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb("1/3","1/5").elliptic_sigma(1j), dps=25) - 0.3396549497136886526515370 + 0.1970690762350931272896772j - """ - tau = any_as_acb(tau) - u = acb.__new__(acb) - acb_elliptic_sigma((u).val, (self).val, (tau).val, getprec()) - return u - - def elliptic_inv_p(self, tau): - r""" - Inverse Weierstrass elliptic function `\sigma^{-1}(z, \tau)` - where *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb("1/3","1/5").elliptic_p(1j).elliptic_inv_p(1j), dps=25) - 0.3333333333333333333333333 + 0.2000000000000000000000000j - """ - tau = any_as_acb(tau) - u = acb.__new__(acb) - acb_elliptic_inv_p((u).val, (self).val, (tau).val, getprec()) - return u - - def elliptic_roots(tau): - r""" - Returns the elliptic roots `e_1, e_2, e_3` given the - lattice parameter `\tau`. - - >>> from flint import showgood - >>> showgood(lambda: acb(0.5+1j).elliptic_roots(), dps=10) - (6.285388119, -3.142694059 + 3.386618325j, -3.142694059 - 3.386618325j) - """ - e1 = acb.__new__(acb) - e2 = acb.__new__(acb) - e3 = acb.__new__(acb) - acb_elliptic_roots((e1).val, (e2).val, (e3).val, (tau).val, getprec()) - return (e1, e2, e3) - - def elliptic_invariants(tau): - r""" - Returns the lattice invariants `g_2, g_3` given the - lattice parameter `\tau`. - - >>> from flint import showgood - >>> showgood(lambda: acb(0.5+1j).elliptic_invariants(), dps=25) - (72.64157667926127619414883, 536.6642788346023116199232) - """ - g1 = acb.__new__(acb) - g2 = acb.__new__(acb) - acb_elliptic_invariants((g1).val, (g2).val, (tau).val, getprec()) - return (g1, g2) - - def dirichlet_eta(s): - r""" - Dirichlet eta function `\eta(s)`. - - >>> from flint import showgood - >>> showgood(lambda: acb(1).dirichlet_eta(), dps=25) - 0.6931471805599453094172321 - >>> showgood(lambda: acb(0).dirichlet_eta(), dps=25) - 0.5000000000000000000000000 - >>> showgood(lambda: acb(0.5+10000j).dirichlet_eta(), dps=25) - -0.08240476492345768707759740 - 0.4458305781469329610368705j - """ - u = acb.__new__(acb) - acb_dirichlet_eta((u).val, (s).val, getprec()) - return u - - def polygamma(self, s): - r""" - Polygamma function `\psi_s(z)` where *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).polygamma(2), dps=25) - 0.05267618908093586035755719 + 0.07303622933440580692454450j - """ - u = acb.__new__(acb) - s = any_as_acb(s) - acb_polygamma((u).val, (s).val, (self).val, getprec()) - return u - - def log_barnes_g(s): - r""" - Logarithmic Barnes G-function `\log G(s)`. Like the logarithmic - gamma function, continuous analytic continuation is implied. - - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).log_barnes_g(), dps=25) - -1.694395396880976849503750 - 3.389316783507118550918827j - >>> showgood(lambda: acb(2+3j).barnes_g().log(), dps=25) - -1.694395396880976849503750 + 2.893868523672467926006460j - """ - u = acb.__new__(acb) - acb_log_barnes_g((u).val, (s).val, getprec()) - return u - - def barnes_g(s): - r""" - Barnes G-function `G(s)`. - - >>> acb(8).barnes_g() - 24883200.0000000 - >>> from flint import showgood - >>> showgood(lambda: acb(2+3j).barnes_g(), dps=25) - -0.1781021386408216960641890 + 0.04504542715447837909120582j - """ - u = acb.__new__(acb) - acb_barnes_g((u).val, (s).val, getprec()) - return u - - def hypgeom_0f1(self, a, bint regularized=False): - r""" - Hypergeometric function `{}_0F_1(a,z)` where the argument *z* - is given by *self* - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(-5).hypgeom_0f1(2.5), dps=25) - 0.003114611044402738470826907 - >>> showgood(lambda: acb(-5).hypgeom_0f1(2.5, regularized=True), dps=25) - 0.002342974810739764377177885 - """ - a = any_as_acb(a) - u = acb.__new__(acb) - acb_hypgeom_0f1((u).val, (a).val, (self).val, regularized, getprec()) - return u - - def hypgeom(self, a, b, bint regularized=False, long n=-1): - r""" - Generalized hypergeometric function `{}_pF_q(a;b;z)`. - The argument *z* is given by *self* and *a* and *b* - are additional lists of complex numbers defining the parameters. - Optionally the regularized hypergeometric function can be - computed. - - >>> from flint import fmpq - >>> from flint import showgood - >>> showgood(lambda: acb.pi().hypgeom([1+1j, 2-2j], [3, fmpq(1,3)]), dps=25) # 2F2 - 144.9760711583421645394627 - 51.06535684838559608699106j - >>> showgood(lambda: acb.pi().hypgeom([1+1j, 2-2j], [3, fmpq(1,3)], regularized=True), dps=25) - 27.05849150326959272369764 - 9.530893707861133993129862j - - The optional parameter *n*, if nonnegative, controls the number - of terms to add in the hypergeometric series. This is just a tuning - parameter: a rigorous error bound is computed regardless of *n*. - """ - cdef long i, p, q - cdef acb_ptr aa, bb - a = [any_as_acb(t) for t in a] - b = [any_as_acb(t) for t in b] - if n != -1: - b += [acb(1)] - p = len(a) - q = len(b) - aa = libc.stdlib.malloc(p * cython.sizeof(acb_struct)) - bb = libc.stdlib.malloc(q * cython.sizeof(acb_struct)) - for i in range(p): - aa[i] = ((a[i])).val[0] - for i in range(q): - bb[i] = ((b[i])).val[0] - u = acb.__new__(acb) - if n == -1: - acb_hypgeom_pfq((u).val, aa, p, bb, q, (self).val, regularized, getprec()) - else: - if regularized: - raise NotImplementedError - acb_hypgeom_pfq_direct((u).val, aa, p, bb, q, (self).val, n, getprec()) - libc.stdlib.free(aa) - libc.stdlib.free(bb) - return u - - def hypgeom_u(self, a, b, long n=-1, bint asymp=False): - r""" - Tricomi's confluent hypergeometric function `U(a,b,z)` - where *z* is given by *self*. - - If *asymp* is set to *True* the asymptotic series is forced. - If `|z|` is small, the attainable accuracy is then limited. - The optional parameter *n*, if nonnegative, controls the number - of terms to add in the asymptotic series. This is just a tuning - parameter: a rigorous error bound is computed regardless of *n*. - - >>> from flint import showgood - >>> showgood(lambda: acb(400+500j).hypgeom_u(1+1j, 2+3j), dps=25) - 0.001836433961463105354717547 - 0.003358699641979853540147122j - >>> showgood(lambda: acb(-30).hypgeom_u(1+1j, 2+3j), dps=25) - 0.7808944974399200669072087 - 0.2674783064947089569672470j - >>> print(acb(-30).hypgeom_u(1+1j, 2+3j, n=0, asymp=True)) - [+/- 3.41] + [+/- 3.41]j - >>> print(acb(-30).hypgeom_u(1+1j, 2+3j, n=30, asymp=True)) - [0.7808944974 +/- 7.46e-11] + [-0.2674783065 +/- 3.31e-11]j - >>> print(acb(-30).hypgeom_u(1+1j, 2+3j, n=60, asymp=True)) - [0.78089 +/- 8.14e-6] + [-0.26748 +/- 5.34e-6]j - """ - a = any_as_acb(a) - b = any_as_acb(b) - if asymp: - t = self**(-a) - u = acb.__new__(acb) - acb_hypgeom_u_asymp((u).val, (a).val, (b).val, (self).val, n, getprec()) - return t * u - else: - u = acb.__new__(acb) - acb_hypgeom_u((u).val, (a).val, (b).val, (self).val, getprec()) - return u - - def hypgeom_1f1(self, a, b, bint regularized=False): - r""" - Kummer's confluent hypergeometric function `{}_1F_1(a,b,z)` - where *z* is given by *self*.. Optionally, computes - the regularized version. - - >>> from flint import showgood - >>> showgood(lambda: acb(40000+50000j).hypgeom_1f1(2+3j, 3+4j), dps=25) - 3.730925582634533963357515e+17366 + 3.199717318207534638202987e+17367j - >>> showgood(lambda: acb(40000+50000j).hypgeom_1f1(2+3j, 3+4j) / acb(3+4j).gamma(), dps=25) - -1.846160890579724375436801e+17368 + 2.721369772032882467996588e+17367j - >>> showgood(lambda: acb(10).hypgeom_1f1(5, -3, regularized=True), dps=25) - 832600407043.6938843410086 - >>> showgood(lambda: acb(10).hypgeom_1f1(-5,-6), dps=25) - 403.7777777777777777777778 - >>> showgood(lambda: acb(10).hypgeom_1f1(-5,-5,regularized=True), dps=25) - 0 - >>> showgood(lambda: acb(10).hypgeom_1f1(-5,-6,regularized=True), dps=25) - 0 - >>> showgood(lambda: acb(10).hypgeom_1f1(-5,-4,regularized=True), dps=25) - -100000.0000000000000000000 - - """ - a = any_as_acb(a) - b = any_as_acb(b) - u = acb.__new__(acb) - acb_hypgeom_1f1((u).val, (a).val, (b).val, (self).val, regularized, getprec()) - return u - - def bessel_j(self, n): - r""" - Bessel function `J_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: acb(5).bessel_j(1), dps=25) - -0.3275791375914652220377343 - >>> showgood(lambda: acb(2+3j).bessel_j(1+2j), dps=25) - 0.5041904509946947234759103 - 0.1765180072689450645147231j - """ - n = any_as_acb(n) - u = acb.__new__(acb) - acb_hypgeom_bessel_j((u).val, (n).val, (self).val, getprec()) - return u - - def bessel_y(self, n): - r""" - Bessel function `Y_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: acb(5).bessel_y(1), dps=25) - 0.1478631433912268448010507 - """ - n = any_as_acb(n) - u = acb.__new__(acb) - acb_hypgeom_bessel_y((u).val, (n).val, (self).val, getprec()) - return u - - def bessel_k(self, n, bint scaled=False): - r""" - Bessel function `K_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - Optionally a scaled Bessel function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(5).bessel_k(1), dps=25) - 0.004044613445452164208365022 - >>> showgood(lambda: acb(5).bessel_k(1, scaled=True), dps=25) - 0.6002738587883125829360457 - >>> showgood(lambda: acb(2+3j).bessel_k(1+2j), dps=25) - -0.09884736370006798963642719 - 0.02870616366668971734065520j - """ - n = any_as_acb(n) - u = acb.__new__(acb) - if scaled: - acb_hypgeom_bessel_k_scaled((u).val, (n).val, (self).val, getprec()) - else: - acb_hypgeom_bessel_k((u).val, (n).val, (self).val, getprec()) - return u - - def bessel_i(self, n, bint scaled=False): - r""" - Bessel function `I_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - Optionally a scaled Bessel function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: acb(5).bessel_i(1), dps=25) - 24.33564214245052719914305 - >>> showgood(lambda: acb(5).bessel_i(1, scaled=True), dps=25) - 0.1639722669445423569261229 - """ - n = any_as_acb(n) - u = acb.__new__(acb) - if scaled: - acb_hypgeom_bessel_i_scaled((u).val, (n).val, (self).val, getprec()) - else: - acb_hypgeom_bessel_i((u).val, (n).val, (self).val, getprec()) - return u - - def root(s, ulong n): - """ - Principal *n*-th root of *s*. - - >>> from flint import showgood - >>> showgood(lambda: acb(-1).root(3), dps=25) - 0.5000000000000000000000000 + 0.8660254037844386467637232j - >>> showgood(lambda: acb(10,11).root(3), dps=25) - 2.364674532267765964410078 + 0.6739866114818132500777466j - """ - v = acb.__new__(acb) - acb_root_ui((v).val, (s).val, n, getprec()) - return v - - @staticmethod - def zeta_zero(n): - """ - Returns the *n*-th nontrivial zero of the Riemann zeta function. - - >>> from flint import showgood - >>> showgood(lambda: acb.zeta_zero(1), dps=25) - 0.5000000000000000000000000 + 14.13472514173469379045725j - >>> showgood(lambda: acb.zeta_zero(2), dps=25) - 0.5000000000000000000000000 + 21.02203963877155499262848j - >>> showgood(lambda: acb.zeta_zero(100), dps=25) - 0.5000000000000000000000000 + 236.5242296658162058024755j - >>> showgood(lambda: acb.zeta_zero(10**6), dps=25) - 0.5000000000000000000000000 + 600269.6770124449555212339j - """ - n = fmpz(n) - if n < 1: - raise ValueError("require n >= 1") - v = acb.__new__(acb) - acb_dirichlet_zeta_zero((v).val, (n).val, getprec()) - return v - - @staticmethod - def zeta_zeros(n, long num): - """ - Returns *num* consecutive nontrivial zeros of the Riemann zeta function - starting at index *n*. - - >>> 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 - """ - cdef long i - cdef acb_ptr w - cdef list v - n = fmpz(n) - if n < 1 or num < 0: - raise ValueError("require n >= 1 and num >= 0") - v = [acb() for i in range(num)] - w = libc.stdlib.malloc(num * cython.sizeof(acb_struct)) - for i in range(num): - w[i] = ((v[i])).val[0] - acb_dirichlet_zeta_zeros(w, (n).val, num, getprec()) - for i in range(num): - ((v[i])).val[0] = w[i] - libc.stdlib.free(w) - return v - - @staticmethod - def integral(func, a, b, params=None, - rel_tol=None, abs_tol=None, - deg_limit=None, eval_limit=None, depth_limit=None, - use_heap=None, verbose=None): - r""" - Computes the integral `\int_a^b f(x) dx` where the integrand - *f* is defined by *func*. - - >>> from flint import arb - >>> from flint import showgood - >>> showgood(lambda: acb.integral(lambda x, _: x.sin(), 0, arb.pi()), dps=25) - 2.000000000000000000000000 - >>> showgood(lambda: acb.integral(lambda x, _: (x + x.sin()).gamma(), 1, 1+1j), dps=25) - -0.2732681890680958866139676 + 0.7064496061603478580993410j - - The function *func* takes two parameters as input: the - argument *x* and a boolean flag *analytic*. If *analytic* - is False, *func* should return `f(x)`, and in this case - there are no restrictions on *f*; for instance, the integrand - can be discontinuous on *x*. - If *analytic* is True, *func* must verify that *f* is analytic - on *x*, and if not, return a non-finite ball instead of `f(x)`. - - The *analytic* flag can be ignored for meromorphic functions, - because evaluation at poles automatically leads to non-finite - balls. However, it *must* be checked for functions that are - non-analytic in some regions (for instance, functions with - branch cuts such as `\sqrt{x}` and `\log(x)`), even if the - integration path does not touch any non-analytic points. - Some methods have an *analytic* option built-in, so the user - simply has to forward this flag: - - >>> from flint import showgood - >>> showgood(lambda: acb.integral(lambda x, _: x.sqrt(), 1, 4), dps=25) # WRONG!!! - 4.669414894781006338774348 - >>> showgood(lambda: acb.integral(lambda x, a: x.sqrt(analytic=a), 1, 4), dps=25) # correct - 4.666666666666666666666667 - - The following works without handling the *analytic* flag, - because the integrand is meromorphic: - - >>> from flint import showgood - >>> showgood(lambda: acb.integral(lambda x, _: x.sech(), -1000, 1000), dps=25) - 3.141592653589793238462643 - - The options *rel_tol* and *abs_tol* specify the relative - and absolute tolerance goal for the integration. - Both default to `2^{-p}` where *p* is the current precision. - - The options *deg_limit*, *eval_limit*, *depth_limit* and - *use_heap* allow control over the amount of work done before - aborting; see the documentation for *acb_calc_integrate* for - details. - """ - cdef IntegrationContext ictx = IntegrationContext() - cdef acb_calc_integrate_opt_t arb_opts - cdef long cgoal, prec - cdef mag_t ctol - cdef arb tmp - cdef acb ca, cb, res - - ca = any_as_acb(a) - cb = any_as_acb(b) - - mag_init(ctol) - - ictx.f = func - ictx.exn_type = None - - acb_calc_integrate_opt_init(arb_opts) - if deg_limit is not None: - arb_opts.deg_limit = deg_limit - if eval_limit is not None: - arb_opts.eval_limit = eval_limit - if depth_limit is not None: - arb_opts.depth_limit = depth_limit - if use_heap is not None: - arb_opts.use_heap = use_heap - if verbose is not None: - arb_opts.verbose = verbose - - prec = ctx.prec - - if rel_tol is None: - cgoal = prec - else: - tmp = any_as_arb(rel_tol) - cgoal = arf_abs_bound_lt_2exp_si(arb_midref(tmp.val)) - cgoal = -cgoal - - if abs_tol is None: - mag_set_ui_2exp_si(ctol, 1, -prec) - else: - tmp = any_as_arb(abs_tol) - arb_get_mag(ctol, tmp.val) - - res = acb.__new__(acb) - - try: - acb_calc_integrate( - res.val, - acb_calc_func_callback, - ictx, - ca.val, cb.val, - cgoal, ctol, arb_opts, prec) - finally: - mag_clear(ctol) - - if ictx.exn_type is not None: - raise ictx.exn_type, ictx.exn_obj, ictx.exn_tb - - return res - - def coulomb(self, l, eta): - r""" - Computes the Coulomb wave functions `F_{\ell}(\eta,z)`, - `G_{\ell}(\eta,z)`, `H^{+}_{\ell}(\eta,z)`, `H^{-}_{\ell}(\eta,z)` - where *z* is given by *self*. - All function values are computed simultaneously and a tuple - is returned. - - >>> from flint import showgood - >>> showgood(lambda: acb(1).coulomb(0.5, 0.25), dps=10) - (0.4283180781, 1.218454487, 1.218454487 + 0.4283180781j, 1.218454487 - 0.4283180781j) - """ - l = any_as_acb(l) - eta = any_as_acb(eta) - F = acb.__new__(acb) - G = acb.__new__(acb) - Hpos = acb.__new__(acb) - Hneg = acb.__new__(acb) - acb_hypgeom_coulomb((F).val, (G).val, (Hpos).val, (Hneg).val, - (l).val, (eta).val, (self).val, getprec()) - return F, G, Hpos, Hneg - - def coulomb_f(self, l, eta): - r""" - Regular Coulomb wave function `F_{\ell}(\eta,z)` where - *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb(1+1j).coulomb_f(0.5, 0.25), dps=25) - 0.3710338871231483199425544 + 0.7267604204004146050054782j - """ - l = any_as_acb(l) - eta = any_as_acb(eta) - F = acb.__new__(acb) - acb_hypgeom_coulomb((F).val, NULL, NULL, NULL, - (l).val, (eta).val, (self).val, getprec()) - return F - - def coulomb_g(self, l, eta): - r""" - Irregular Coulomb wave function `G_{\ell}(\eta,z)` where - *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: acb(1+1j).coulomb_g(0.5, 0.25), dps=25) - 1.293346292234270672155324 - 0.3516893313311703662702556j - """ - l = any_as_acb(l) - eta = any_as_acb(eta) - G = acb.__new__(acb) - acb_hypgeom_coulomb(NULL, (G).val, NULL, NULL, - (l).val, (eta).val, (self).val, getprec()) - return G diff --git a/src/flint/types/acb_mat.pxd b/src/flint/types/acb_mat.pxd deleted file mode 100644 index e192cc4c..00000000 --- a/src/flint/types/acb_mat.pxd +++ /dev/null @@ -1,7 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat -from flint.flintlib.functions.acb_mat cimport acb_mat_t - -cdef class acb_mat(flint_mat): - cdef acb_mat_t val - cpdef long nrows(self) - cpdef long ncols(self) diff --git a/src/flint/types/acb_mat.pyx b/src/flint/types/acb_mat.pyx deleted file mode 100644 index 5bf18681..00000000 --- a/src/flint/types/acb_mat.pyx +++ /dev/null @@ -1,849 +0,0 @@ -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_base cimport flint_mat -from flint.types.arb_mat cimport arb_mat -from flint.types.fmpz_mat cimport fmpz_mat -from flint.types.fmpq_mat cimport fmpq_mat -from flint.types.arb cimport arb -from flint.types.acb cimport acb -from flint.types.acb_poly cimport acb_poly -from flint.types.acb cimport any_as_acb -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq - -from flint.flintlib.functions.fmpz_mat cimport fmpz_mat_nrows, fmpz_mat_ncols -from flint.flintlib.functions.fmpq_mat cimport fmpq_mat_nrows, fmpq_mat_ncols -from flint.flintlib.functions.mag cimport * -from flint.flintlib.functions.arb cimport * -from flint.flintlib.types.arb cimport ( - mag_struct, - arb_radref, - arb_midref, - arb_mat_entry, - arb_mat_nrows, - arb_mat_ncols, -) -from flint.flintlib.functions.arb_mat cimport * -from flint.flintlib.functions.arf cimport * -from flint.flintlib.functions.acb cimport * -from flint.flintlib.functions.acb_mat cimport * -from flint.flintlib.types.acb cimport ( - acb_realref, - acb_imagref, - acb_mat_struct, - acb_mat_entry, - acb_mat_nrows, - acb_mat_ncols, -) - -cimport cython - -cdef acb_mat_coerce_operands(x, y): - if isinstance(y, (fmpz_mat, fmpq_mat, arb_mat)): - return x, acb_mat(y) - if isinstance(y, (int, float, complex, fmpz, fmpq, arb, acb)): - return x, acb_mat(x.nrows(), x.ncols(), y) - return NotImplemented, NotImplemented - -cdef acb_mat_coerce_scalar(x, y): - if isinstance(y, (int, float, complex, fmpz, fmpq, arb, acb)): - return x, any_as_acb(y) - return NotImplemented, NotImplemented - -cdef class acb_mat(flint_mat): - """ - Represents a matrix over the complex numbers. - - >>> A = acb_mat([[1,2+1j],[3,4]]) ** 2 / 5 - >>> print(A.str(5, radius=False)) - [1.4000 + 0.60000j, 2.0000 + 1.0000j] - [ 3.0000, 4.4000 + 0.60000j] - - """ - # cdef acb_mat_t val - - def __cinit__(self): - acb_mat_init(self.val, 0, 0) - - def __dealloc__(self): - acb_mat_clear(self.val) - - @classmethod - def convert_operand(cls, x): - """ - Attempts to convert *x* to an *acb_mat*, returning NotImplemented - if unsuccessful. - """ - if typecheck(x, cls): - return x - if typecheck(x, fmpz_mat) or typecheck(x, fmpq_mat) or typecheck(x, arb_mat): - return cls(x) - return NotImplemented - - @classmethod - def convert(cls, x): - """ - Attempts to convert *x* to an *acb_mat*, raising TypeError if - unsuccessful. - """ - x = cls.convert_operand(x) - if x is NotImplemented: - raise TypeError("unable to convert type %s to type %s" % (type(x), cls)) - return x - - @cython.embedsignature(False) - def __init__(self, *args): - cdef long m, n, i, j - if len(args) == 1: - val = args[0] - if typecheck(val, acb_mat): - m = acb_mat_nrows((val).val) - n = acb_mat_ncols((val).val) - acb_mat_init(self.val, m, n) - acb_mat_set(self.val, (val).val) - elif typecheck(val, arb_mat): - m = arb_mat_nrows((val).val) - n = arb_mat_ncols((val).val) - acb_mat_init(self.val, m, n) - for i in range(m): - for j in range(n): - acb_set_arb(acb_mat_entry(self.val, i, j), arb_mat_entry((val).val, i, j)) - elif typecheck(val, fmpz_mat): - m = fmpz_mat_nrows((val).val) - n = fmpz_mat_ncols((val).val) - acb_mat_init(self.val, m, n) - acb_mat_set_fmpz_mat(self.val, (val).val) - elif typecheck(val, fmpq_mat): - m = fmpq_mat_nrows((val).val) - n = fmpq_mat_ncols((val).val) - acb_mat_init(self.val, m, n) - acb_mat_set_fmpq_mat(self.val, (val).val, getprec()) - elif isinstance(val, (list, tuple)): - m = len(val) - n = 0 - if m != 0: - if not isinstance(val[0], (list, tuple)): - raise TypeError("single input to acb_mat must be a list of lists") - n = len(val[0]) - for i from 1 <= i < m: - if len(val[i]) != n: - raise ValueError("input rows have different lengths") - acb_mat_init(self.val, m, n) - for i from 0 <= i < m: - row = val[i] - for j from 0 <= j < n: - x = acb(row[j]) - acb_set(acb_mat_entry(self.val, i, j), (x).val) - elif hasattr(val, "rows"): # allows conversion from mpmath matrices - m = val.rows - n = val.cols - acb_mat_init(self.val, m, n) - for i from 0 <= i < m: - for j from 0 <= j < n: - x = acb(val[i, j]) - acb_set(acb_mat_entry(self.val, i, j), (x).val) - else: - raise TypeError("cannot create acb_mat from input of type %s" % type(val)) - elif len(args) == 2: - m, n = args - acb_mat_init(self.val, m, n) - elif len(args) == 3: - m, n, entries = args - acb_mat_init(self.val, m, n) - if isinstance(entries, (int, float, complex, fmpz, fmpq, arb, acb)): - c = entries - entries = [0] * (m * n) - for i in range(min(m, n)): - entries[i*n + i] = c - else: - entries = list(entries) - if len(entries) != m*n: - raise ValueError("list of entries has the wrong length") - for i from 0 <= i < m: - for j from 0 <= j < n: - x = acb(entries[i*n + j]) - acb_set(acb_mat_entry(self.val, i, j), (x).val) - else: - raise ValueError("acb_mat: expected 1-3 arguments") - - def __bool__(self): - raise NotImplementedError - - cpdef long nrows(s): - """ - Returns the number of rows of *s*. - """ - return acb_mat_nrows(s.val) - - cpdef long ncols(s): - """ - Returns the number of columns of *s*. - """ - return acb_mat_ncols(s.val) - - def __getitem__(self, index): - cdef long i, j - cdef acb x - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise ValueError("index %i,%i exceeds matrix dimensions" % (i, j)) - x = acb.__new__(acb) - acb_set(x.val, acb_mat_entry(self.val, i, j)) - return x - - def __setitem__(self, index, value): - cdef long i, j - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise ValueError("index %i,%i exceeds matrix dimensions" % (i, j)) - c = any_as_acb(value) - acb_set(acb_mat_entry(self.val, i, j), (c).val) - - def transpose(s): - """ - Returns the transpose of *s*. - """ - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_ncols(s.val), acb_mat_nrows(s.val)) - acb_mat_transpose(u.val, s.val) - return u - - def conjugate(s): - """ - Returns the entrywise conjugate (not the conjugate transpose) of *s*. - - >>> acb_mat([[1-2j, 1+3j]]).conjugate() - [1.00000000000000 + 2.00000000000000j, 1.00000000000000 - 3.00000000000000j] - """ - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_conjugate(u.val, s.val) - return u - - def det(s): - """ - Returns the determinant of the square matrix *s* as an *acb*. - - >>> from flint import showgood - >>> A = acb_mat(3, 3, range(9)) - >>> showgood(lambda: A.det(), dps=25) # singular - 0 - >>> A[2,2] = 10 - >>> showgood(lambda: A.det(), dps=25) - -6.000000000000000000000000 - >>> showgood(lambda: (A * A).det()) - 36.0000000000000 - >>> print(acb_mat(0, 0).det()) - 1.00000000000000 - """ - cdef acb d - if acb_mat_nrows(s.val) != acb_mat_ncols(s.val): - raise ValueError("matrix must be square") - d = acb.__new__(acb) - acb_mat_det(d.val, s.val, getprec()) - return d - - def __pos__(s): - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_set(u.val, s.val) # round? - return u - - def __neg__(s): - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_neg(u.val, s.val) # round? - return u - - def __add__(s, t): - cdef long m, n - if not isinstance(t, acb_mat): - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - - m = (s).nrows() - n = (s).ncols() - if m != (t).nrows() or n != (t).ncols(): - raise ValueError("incompatible shapes for matrix addition") - u = acb_mat.__new__(acb_mat) - acb_mat_init((u).val, m, n) - acb_mat_add((u).val, (s).val, (t).val, getprec()) - return u - - def __radd__(s, t): - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - cdef long m, n - if not isinstance(t, acb_mat): - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - - m = (s).nrows() - n = (s).ncols() - if m != (t).nrows() or n != (t).ncols(): - raise ValueError("incompatible shapes for matrix addition") - u = acb_mat.__new__(acb_mat) - acb_mat_init((u).val, m, n) - acb_mat_sub((u).val, (s).val, (t).val, getprec()) - return u - - def __rsub__(s, t): - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def _scalar_mul_(s, acb t): - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_scalar_mul_acb(u.val, s.val, t.val, getprec()) - return u - - def __mul__(s, t): - cdef acb_mat u - if not isinstance(t, acb_mat): - c, d = acb_mat_coerce_scalar(s, t) - if c is not NotImplemented: - return c._scalar_mul_(d) - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - - if acb_mat_ncols((s).val) != acb_mat_nrows((t).val): - raise ValueError("incompatible shapes for matrix multiplication") - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows((s).val), acb_mat_ncols((t).val)) - acb_mat_mul(u.val, (s).val, (t).val, getprec()) - return u - - def __rmul__(s, t): - c, d = acb_mat_coerce_scalar(s, t) - if c is not NotImplemented: - return c._scalar_mul_(d) - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - def _scalar_div_(s, acb t): - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_scalar_div_acb(u.val, s.val, t.val, getprec()) - return u - - def __truediv__(s, t): - if typecheck(s, acb_mat): - s, t = acb_mat_coerce_scalar(s, t) - if s is NotImplemented: - return s - return s._scalar_div_(t) - return NotImplemented - - def __pow__(s, e, m): - cdef acb_mat u - cdef ulong exp - cdef long n - if not typecheck(s, acb_mat): - return NotImplemented - exp = e - n = acb_mat_nrows((s).val) - if n != acb_mat_ncols((s).val): - raise ValueError("matrix must be square") - if m is not None: - raise NotImplementedError("modular matrix exponentiation") - u = acb_mat.__new__(acb_mat) - acb_mat_init((u).val, n, n) - acb_mat_pow_ui((u).val, (s).val, exp, getprec()) - return u - - def inv(s, bint nonstop=False): - """ - Returns the inverse matrix of the square matrix *s*. - - If *s* is numerically singular, raises :exc:`ZeroDivisionError` - unless *nonstop* is set in which case a matrix with NaN entries - is returned. - - >>> A = acb_mat(2, 2, [1, 5, 2, 4]) - >>> print(A * A.inv()) - [[1.00000000000000 +/- 6.11e-16], [+/- 3.34e-16]] - [ [+/- 4.45e-16], [1.00000000000000 +/- 5.56e-16]] - >>> A = acb_mat(2, 2, [1, 5, 2, 10]) - >>> A.inv() - Traceback (most recent call last): - ... - ZeroDivisionError: matrix is singular - >>> A.inv(nonstop=True) - [nan + nanj, nan + nanj] - [nan + nanj, nan + nanj] - - """ - cdef acb_mat u - cdef long i, j - if acb_mat_nrows(s.val) != acb_mat_ncols(s.val): - raise ValueError("matrix must be square") - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - if not acb_mat_inv(u.val, s.val, getprec()): - if nonstop: - for i from 0 <= i < acb_mat_nrows(u.val): - for j from 0 <= j < acb_mat_nrows(u.val): - acb_indeterminate(acb_mat_entry(u.val, i, j)) - else: - raise ZeroDivisionError("matrix is singular") - return u - - def solve(s, t, bint nonstop=False, algorithm=None): - """ - Solves `AX = B` where *A* is a square matrix given by *s* and - `B` is a matrix given by *t*. - - If *A* is numerically singular, raises :exc:`ZeroDivisionError` - unless *nonstop* is set in which case a matrix with NaN entries - is returned. - - >>> A = acb_mat(2, 2, [1, 2, 3, 4]) - >>> X = acb_mat(2, 3, range(6)) - >>> B = A * X - >>> print(A.solve(B)) - [ [+/- 4.74e-15], [1.00000000000000 +/- 4.78e-15], [2.00000000000000 +/- 8.52e-15]] - [[3.00000000000000 +/- 3.56e-15], [4.00000000000000 +/- 3.59e-15], [5.00000000000000 +/- 6.28e-15]] - >>> acb_mat([[1,1],[0,0]]).solve(acb_mat(2,3), nonstop=True) - [nan + nanj, nan + nanj, nan + nanj] - [nan + nanj, nan + nanj, nan + nanj] - - The optional *algorithm* can be None (default), "lu", or "precond". - It can also be set to "approx" in which case an approximate - floating-point solution (warning: without error bounds!) is returned. - """ - cdef acb_mat u - cdef bint res - cdef long i, j - t = acb_mat.convert(t) - if (acb_mat_nrows(s.val) != acb_mat_ncols(s.val) or - acb_mat_nrows(s.val) != acb_mat_nrows((t).val)): - raise ValueError("need a square system and compatible right hand side") - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows((t).val), acb_mat_ncols((t).val)) - if algorithm is None: - res = acb_mat_solve(u.val, s.val, (t).val, getprec()) - elif algorithm == 'lu': - res = acb_mat_solve_lu(u.val, s.val, (t).val, getprec()) - elif algorithm == 'precond': - res = acb_mat_solve_precond(u.val, s.val, (t).val, getprec()) - elif algorithm == 'approx': - res = acb_mat_approx_solve(u.val, s.val, (t).val, getprec()) - else: - raise ValueError("unknown algorithm") - if not res: - if nonstop: - for i from 0 <= i < acb_mat_nrows(u.val): - for j from 0 <= j < acb_mat_ncols(u.val): - acb_indeterminate(acb_mat_entry(u.val, i, j)) - else: - raise ZeroDivisionError("singular matrix in solve()") - return u - - def exp(s): - """ - Returns the matrix exponential of *s*. - - >>> print(acb_mat(2, 2, [1, 4, -2, 1]).exp()) - [ [-2.58607310345045 +/- 5.06e-15], [1.18429895089106 +/- 1.15e-15]] - [[-0.592149475445530 +/- 5.73e-16], [-2.58607310345045 +/- 5.06e-15]] - """ - cdef acb_mat u - if acb_mat_nrows(s.val) != acb_mat_ncols(s.val): - raise ValueError("matrix must be square") - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_exp(u.val, s.val, getprec()) - return u - - def charpoly(s): - """ - Returns the characteristic polynomial of *s* as an *acb_poly*. - - >>> print(acb_mat(2, 2, [1, 1, 1, 0]).charpoly()) - 1.00000000000000*x^2 + (-1.00000000000000)*x + (-1.00000000000000) - """ - cdef acb_poly u - if acb_mat_nrows(s.val) != acb_mat_ncols(s.val): - raise ValueError("matrix must be square") - u = acb_poly.__new__(acb_poly) - acb_mat_charpoly(u.val, s.val, getprec()) - return u - - def mid(s): - """ - Returns the matrix consisting of the midpoints of the entries of *s*. - - >>> acb_mat([["1.5 +/- 0.1", 3]]).mid() - [1.50000000000000, 3.00000000000000] - """ - cdef acb_mat u - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, acb_mat_nrows(s.val), acb_mat_ncols(s.val)) - acb_mat_get_mid(u.val, s.val) - return u - - def trace(s): - """ - Returns the trace of the square matrix *s* as an *acb*. - - >>> acb_mat([[3,4],[5,7]]).trace() - 10.0000000000000 - """ - cdef acb d - if acb_mat_nrows(s.val) != acb_mat_ncols(s.val): - raise ValueError("matrix must be square") - d = acb.__new__(acb) - acb_mat_trace(d.val, s.val, getprec()) - return d - - @classmethod - def dft(cls, long n, long m=-1): - """ - Returns the size *n* by *n* DFT matrix (optionally a separate - number of columns *m* can be given in which case the periodic - extension of the smaller dimension is used). - - >>> print(acb_mat.dft(3).str(5, radius=False)) - [0.57735, 0.57735, 0.57735] - [0.57735, -0.28868 - 0.50000j, -0.28868 + 0.50000j] - [0.57735, -0.28868 + 0.50000j, -0.28868 - 0.50000j] - - """ - cdef acb_mat u - if m < 0: - m = n - assert n >= 0 - u = acb_mat.__new__(acb_mat) - acb_mat_init(u.val, n, m) - acb_mat_dft(u.val, 0, getprec()) - return u - - def overlaps(s, acb_mat t): - """ - Returns whether *s* and *t* overlap (in the sense of balls). - - >>> A = acb_mat([[1,2],[3,4]]) - >>> ((A / 3) * 3).overlaps(A) - True - >>> ((A / 3) * 3 + 0.0001).overlaps(A) - False - """ - return bool(acb_mat_overlaps(s.val, t.val)) - - def contains(s, t): - """ - Returns whether *t* is contained in *s* (in the sense of balls). - - >>> from flint import fmpz_mat - >>> from flint import fmpq_mat - >>> from flint import arb_mat - >>> A = acb_mat([[1,2],[3,4]]) - >>> ((A / 3) * 3).contains(A) - True - >>> A.contains((A / 3) * 3) - False - >>> ((A / 3) * 3).contains(fmpz_mat([[1,2],[3,4]])) - True - >>> ((A / 3) * 3).contains(fmpz_mat([[1,2],[3,5]])) - False - >>> (A / 3).contains(fmpq_mat([[1,2],[3,4]]) / 3) - True - >>> ((A / 3) * 3).contains(arb_mat([[1,2],[3,4]])) - True - """ - if isinstance(t, acb_mat): - return bool(acb_mat_contains(s.val, (t).val)) - if isinstance(t, arb_mat): - return bool(acb_mat_contains(s.val, ((acb_mat(t))).val)) - if isinstance(t, fmpz_mat): - return bool(acb_mat_contains_fmpz_mat(s.val, (t).val)) - if isinstance(t, fmpq_mat): - return bool(acb_mat_contains_fmpq_mat(s.val, (t).val)) - raise TypeError("expected a matrix of compatible type") - - def chop(s, tol): - """ - Returns a copy of *s* where real and imaginary parts of entries - that are bounded by *tol* in magnitude have been replaced by - exact zeros. - - >>> A = acb_mat([[1, 1+1e-20j], [1e-20+1j, 1e-20+1e-20j]]) - >>> A.chop(1e-6) - [ 1.00000000000000, 1.00000000000000] - [1.00000000000000j, 0] - - """ - cdef acb_mat u - cdef arb b - cdef long i, j, n, m - u = acb_mat(s) - n = s.nrows() - m = s.ncols() - b = arb(tol) - arb_get_mag_lower(arb_radref(b.val), b.val) - arf_zero(arb_midref(b.val)) - for i from 0 <= i < n: - for j from 0 <= j < m: - # and arb_contains_zero(...)? - if arb_contains(b.val, acb_realref(acb_mat_entry(u.val, i, j))): - arb_zero(acb_realref(acb_mat_entry(u.val, i, j))) - if arb_contains(b.val, acb_imagref(acb_mat_entry(u.val, i, j))): - arb_zero(acb_imagref(acb_mat_entry(u.val, i, j))) - return u - - def __richcmp__(s, t, int op): - cdef bint res - if not (op == 2 or op == 3): - raise ValueError("comparing matrices") - if type(s) is not type(t): - s, t = acb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - if op == 2: - res = acb_mat_eq((s).val, (t).val) - else: - res = acb_mat_ne((s).val, (t).val) - return res - - @property - def real(s): - """ - Entrywise real part of this matrix as an *arb_mat*. - - >>> print(acb_mat.dft(3).real.str(5, radius=False)) - [0.57735, 0.57735, 0.57735] - [0.57735, -0.28868, -0.28868] - [0.57735, -0.28868, -0.28868] - """ - cdef arb_mat u - cdef long i, j, n, m - n = s.nrows() - m = s.ncols() - u = arb_mat(n, m) - for i from 0 <= i < n: - for j from 0 <= j < m: - acb_get_real(arb_mat_entry(u.val, i, j), acb_mat_entry(s.val, i, j)) - return u - - @property - def imag(s): - """ - Entrywise imaginary part of this matrix as an *arb_mat*. - - >>> print(acb_mat.dft(3).imag.str(5, radius=False)) - [0, 0, 0] - [0, -0.50000, 0.50000] - [0, 0.50000, -0.50000] - """ - cdef arb_mat u - cdef long i, j, n, m - n = s.nrows() - m = s.ncols() - u = arb_mat(n, m) - for i from 0 <= i < n: - for j from 0 <= j < m: - acb_get_imag(arb_mat_entry(u.val, i, j), acb_mat_entry(s.val, i, j)) - return u - - def eig(s, bint left=False, bint right=False, multiple=False, algorithm=None, tol=None, long maxiter=0, bint nonstop=False): - r""" - Computes eigenvalues and optionally eigenvectors of this matrix. - Returns either *E*, (*E*, *L*), (*E*, *R*) or (*E*, *L*, *R*) - depending on whether the flags *left* and *right* are set, - where *E* is a list of the eigenvalues, *L* is a matrix - with the left eigenvectors as rows, and *R* is a matrix - with the right eigenvectors as columns. - - The *algorithm* can be "rump", "vdhoeven_mourrain", or *None* - to use a default algorithm. Typically "rump" is slower and more - accurate while "vdhoeven_mourrain" (the current default) - is faster and less accurate. - - >>> A = acb_mat([[2,3,5],[7,11,13],[17,19,23]]) - >>> for c in A.eig(): print(c) - ... - [1.105299634957 +/- 6.34e-13] + [+/- 1.83e-13]j - [-1.917027627441 +/- 2.64e-13] + [+/- 1.83e-13]j - [36.811727992483 +/- 6.97e-13] + [+/- 1.83e-13]j - >>> for c in A.eig(algorithm="rump"): print(c) # doctest: +SKIP - ... - [1.10529963495745 +/- 4.71e-15] + [+/- 2.92e-15]j - [-1.91702762744092 +/- 8.45e-15] + [+/- 3.86e-15]j - [36.8117279924835 +/- 4.72e-14] + [+/- 9.07e-15]j - - With the left and right eigenvector matrices, a complete - diagonalization of the matrix is produced: - - >>> A = acb_mat([[2,3,5],[7,11,13],[17,19,23]]) - >>> E, L, R = A.eig(left=True, right=True) - >>> D = acb_mat(3,3) - >>> for i in range(3): D[i,i] = E[i] - ... - >>> (L*A*R - D).contains(acb_mat(3,3)) - True - >>> (R*D*L - A).contains(acb_mat(3,3)) - True - - Ill-conditioned or large matrices may require high precision - to isolate the eigenvalues:: - - >>> from flint import showgood - >>> from flint import arb_mat - >>> sum(acb_mat(arb_mat.hilbert(20,20)).eig()) - Traceback (most recent call last): - ... - ValueError: failed to isolate eigenvalues (try higher prec, multiple=True for multiple eigenvalues, or nonstop=True to avoid the exception) - >>> sum(acb_mat(arb_mat.hilbert(20,20)).eig(nonstop=True)) - nan + nanj - >>> showgood(lambda: sum(acb_mat(arb_mat.hilbert(20,20)).eig(nonstop=True)), parts=False) - 2.47967321036454 + 0e-55j - - With default options, the method only succeeds if all eigenvalues can be - isolated. Multiple (overlapping) eigenvalues can be handled by - setting *multiple* = *True*. - - >>> acb_mat.dft(4).eig() - Traceback (most recent call last): - ... - ValueError: failed to isolate eigenvalues (try higher prec, multiple=True for multiple eigenvalues, or nonstop=True to avoid the exception) - >>> acb_mat.dft(4).eig(nonstop=True) - [nan + nanj, nan + nanj, nan + nanj, nan + nanj] - >>> acb_mat.dft(4).eig(multiple=True) # doctest: +SKIP - [[-1.0000000000000 +/- 2.26e-15] + [+/- 1.23e-15]j, [+/- 4.96e-16] + [-1.00000000000000 +/- 3.72e-16]j, [1.00000000000000 +/- 4.98e-16] + [+/- 3.42e-16]j, [1.00000000000000 +/- 4.98e-16] + [+/- 3.42e-16]j] - - At this time, computing the eigenvectors is not supported - with multiple eigenvalues: - - >>> acb_mat.dft(4).eig(multiple=True, right=True) - Traceback (most recent call last): - ... - NotImplementedError: eigenvectors not supported with multiple=True - - The *algorithm* can also be set to "approx" to compute - approximate eigenvalues and/or eigenvectors without error bounds. - - >>> for c in acb_mat.dft(4).eig(algorithm="approx"): print(c.str(radius=False)) # doctest: +SKIP - ... - -0.999999999999999 - 7.85046229341892e-17j - -2.35513868802566e-16 - 1.00000000000000j - 1.00000000000000 - 6.64346650360854e-17j - 0.999999999999999 - 5.14675360671472e-17j - - If *algorithm* is set to "approx", then *multiple* has - no effect, and both eigenvalues and eigenvectors can be computed - regardless of overlap. - - >>> E = acb_mat.dft(4).eig(algorithm="approx") - >>> E, R = acb_mat.dft(4).eig(right=True, algorithm="approx") - >>> E, L = acb_mat.dft(4).eig(left=True, algorithm="approx") - >>> E, L, R = acb_mat.dft(4).eig(left=True, right=True, algorithm="approx") - - """ - cdef acb_mat E, L, R - cdef acb_mat_struct *LP - cdef acb_mat_struct *RP - cdef mag_struct * magp - cdef long i, n, prec - cdef int success - cdef mag_t tolm - n = s.nrows() - if n != s.ncols(): - raise ValueError("matrix must be square") - prec = getprec() - E = acb_mat(1, n) - if left: - L = acb_mat(n, n) - LP = &(L.val[0]) - else: - LP = NULL - if right or algorithm != "approx": - R = acb_mat(n, n) - RP = &(R.val[0]) - else: - RP = NULL - if tol is not None: - mag_init(tolm) - tol = arb(tol) - arb_get_mag(tolm, (tol).val) - magp = tolm - else: - magp = NULL - if n != 0: - if algorithm == "approx": - acb_mat_approx_eig_qr(acb_mat_entry(E.val, 0, 0), - LP, RP, s.val, magp, maxiter, getprec()) - else: - acb_mat_approx_eig_qr(acb_mat_entry(E.val, 0, 0), - NULL, RP, s.val, magp, maxiter, getprec()) - if multiple: - if left or right: - raise NotImplementedError("eigenvectors not supported with multiple=True") - if algorithm == "rump": - success = acb_mat_eig_multiple_rump(acb_mat_entry(E.val, 0, 0), - s.val, acb_mat_entry(E.val, 0, 0), RP, prec) - else: - success = acb_mat_eig_multiple(acb_mat_entry(E.val, 0, 0), - s.val, acb_mat_entry(E.val, 0, 0), RP, prec) - else: - if algorithm == "rump": - success = acb_mat_eig_simple_rump(acb_mat_entry(E.val, 0, 0), - LP, RP, s.val, acb_mat_entry(E.val, 0, 0), RP, prec) - elif algorithm == "vdhoeven_mourrain": - success = acb_mat_eig_simple_vdhoeven_mourrain(acb_mat_entry(E.val, 0, 0), - LP, RP, s.val, acb_mat_entry(E.val, 0, 0), RP, prec) - else: - success = acb_mat_eig_simple(acb_mat_entry(E.val, 0, 0), - LP, RP, s.val, acb_mat_entry(E.val, 0, 0), RP, prec) - if not (nonstop or success): - raise ValueError("failed to isolate eigenvalues (try higher prec, multiple=True for multiple eigenvalues, or nonstop=True to avoid the exception)") - if tol is not None: - mag_clear(tolm) - Elist = [acb() for i in range(n)] - for i in range(n): - acb_swap(((Elist [i])).val, acb_mat_entry(E.val, 0, i)) - if not left and not right: - return Elist - if left and right: - return Elist, L, R - if left: - return Elist, L - return Elist, R - - def theta(tau, z, square=False): - r""" - Computes the vector valued Riemann theta function - `(\theta_{a,b}(z, \tau) : a, b \in \{0,1\}^{g})` or its squares, - where `\tau` is given by ``self``. - - This is a wrapper for :func:`.acb_theta.acb_theta`; see the - documentation for that method for details and examples. - This follows the same conventions of the C-function - `acb_theta_all `_ - for the ordering of the theta characteristics. - - """ - try: - from .acb_theta import acb_theta - except ImportError: - raise NotImplementedError("acb_mat.theta needs Flint >= 3.1.0") - return acb_theta(z, tau, square=square) diff --git a/src/flint/types/acb_poly.pxd b/src/flint/types/acb_poly.pxd deleted file mode 100644 index 5679a0a4..00000000 --- a/src/flint/types/acb_poly.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_poly - -from flint.flintlib.functions.acb_poly cimport acb_poly_t - -cdef acb_poly_set_list(acb_poly_t poly, list val, long prec) -cdef class acb_poly(flint_poly): - cdef acb_poly_t val - cpdef long length(self) - cpdef long degree(self) diff --git a/src/flint/types/acb_poly.pyx b/src/flint/types/acb_poly.pyx deleted file mode 100644 index b52de19e..00000000 --- a/src/flint/types/acb_poly.pyx +++ /dev/null @@ -1,516 +0,0 @@ -from cpython.list cimport PyList_Size as PyList_GET_SIZE -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_base cimport flint_poly -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.arb_poly cimport arb_poly -from flint.types.acb cimport acb_set_python -from flint.types.acb cimport any_as_acb -from flint.types.acb cimport acb -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq -from flint.types.arb cimport arb - -from flint.flintlib.functions.mag cimport * -from flint.flintlib.functions.arf cimport * -from flint.flintlib.functions.arb cimport * -from flint.flintlib.types.arb cimport arb_midref -from flint.flintlib.functions.acb cimport * -from flint.flintlib.types.acb cimport acb_struct -from flint.flintlib.functions.acb_poly cimport * -cimport libc.stdlib - -cdef acb_poly_coerce_operands(x, y): - if isinstance(y, (int, float, complex, fmpz, fmpq, arb, acb, fmpz_poly, fmpq_poly, arb_poly)): - return x, acb_poly(y) - return NotImplemented, NotImplemented - -cdef acb_poly_set_list(acb_poly_t poly, list val, long prec): - cdef long i, n - cdef acb_t x - n = PyList_GET_SIZE(val) - acb_poly_fit_length(poly, n) - acb_init(x) - for i in range(n): - if typecheck(val[i], acb): - acb_poly_set_coeff_acb(poly, i, ((val[i])).val) - elif acb_set_python(x, val[i], 1): - acb_poly_set_coeff_acb(poly, i, x) - else: - acb_clear(x) - raise TypeError("unsupported coefficient type for acb_poly") - acb_clear(x) - -cdef int acb_vec_check_tol(acb_srcptr vec, long n, tol) except -1: - cdef acb t - tol = arb(tol) - for i in range(n): - t = acb.__new__(acb) - acb_set(t.val, &vec[i]) - if not (abs(t.rad()) <= tol): - return 0 - return 1 - -cdef class acb_poly(flint_poly): - - # cdef acb_poly_t val - - def __cinit__(self): - acb_poly_init(self.val) - - def __dealloc__(self): - acb_poly_clear(self.val) - - def __init__(self, val=None): - if val is not None: - if typecheck(val, acb_poly): - acb_poly_set(self.val, (val).val) - elif typecheck(val, arb_poly): - acb_poly_set_arb_poly(self.val, (val).val) - elif typecheck(val, fmpz_poly): - acb_poly_set_fmpz_poly(self.val, (val).val, getprec()) - elif typecheck(val, fmpq_poly): - acb_poly_set_fmpq_poly(self.val, (val).val, getprec()) - elif typecheck(val, list): - acb_poly_set_list(self.val, val, getprec()) - else: - val = any_as_acb(val) - acb_poly_set_acb(self.val, (val).val) - - def __len__(self): - return acb_poly_length(self.val) - - cpdef long length(self): - return acb_poly_length(self.val) - - cpdef long degree(self): - return acb_poly_degree(self.val) - - def __getitem__(self, long i): - cdef acb x - x = acb() - if i >= 0: - acb_poly_get_coeff_acb(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if not typecheck(x, acb): - x = acb(x) - acb_poly_set_coeff_acb(self.val, i, (x).val) - - def repr(self): - return "acb_poly([%s])" % (", ".join(map(str, self))) - - @classmethod - def from_roots(cls, roots): - """ - Constructs the monic polynomial whose roots are the given complex numbers. - - >>> acb_poly.from_roots(range(4)) - 1.00000000000000*x^4 + (-6.00000000000000)*x^3 + 11.0000000000000*x^2 + (-6.00000000000000)*x - """ - cdef acb_ptr xs - cdef long i, n - roots = [any_as_acb(x) for x in roots] - n = len(roots) - xs = libc.stdlib.malloc(sizeof(acb_struct) * n) - for i in range(n): - xs[i] = ((roots[i])).val[0] - u = acb_poly.__new__(acb_poly) - acb_poly_product_roots((u).val, xs, n, getprec()) - libc.stdlib.free(xs) - return u - - def evaluate(self, xs, algorithm='fast'): - """ - Multipoint evaluation: evaluates *self* at the list of - points *xs*. The algorithm can be 'iter' or 'fast'. The 'fast' - algorithm is asymptotically fast, but has worse numerical stability. - - Note: for ordinary single-point evaluation, just call the polynomial - with the point as the argument. - """ - cdef acb_ptr xsv, ysv - cdef long i, n - assert algorithm in ('fast', 'iter') - xs = [any_as_acb(x) for x in xs] - n = len(xs) - if n == 0: - return [] - ys = [acb.__new__(acb) for i in range(n)] - xsv = libc.stdlib.malloc(sizeof(acb_struct) * n) - ysv = libc.stdlib.malloc(sizeof(acb_struct) * n) - for i in range(n): - xsv[i] = ((xs[i])).val[0] - ysv[i] = ((ys[i])).val[0] - if algorithm == 'fast': - acb_poly_evaluate_vec_fast(ysv, (self).val, xsv, n, getprec()) - else: - acb_poly_evaluate_vec_iter(ysv, (self).val, xsv, n, getprec()) - for i in range(n): # move values - ((ys[i])).val[0] = ysv[i] - libc.stdlib.free(xsv) - libc.stdlib.free(ysv) - return ys - - @classmethod - def interpolate(cls, xs, ys, algorithm='fast'): - """ - Constructs the unique interpolating polynomial of length at most *n* - taking the values *ys* when evaluated at the *n* distinct points *xs*. - Algorithm can be 'newton', 'barycentric' or 'fast'. The 'fast' - algorithm is asymptotically fast, but has worse numerical stability. - """ - cdef acb_ptr xsv, ysv - cdef long i, n - assert algorithm in ('fast', 'newton', 'barycentric') - xs = [any_as_acb(x) for x in xs] - ys = [any_as_acb(y) for y in ys] - n = len(xs) - if len(ys) != n: - raise ValueError("xs and ys must have the same length") - xsv = libc.stdlib.malloc(sizeof(acb_struct) * n) - ysv = libc.stdlib.malloc(sizeof(acb_struct) * n) - for i in range(n): - xsv[i] = ((xs[i])).val[0] - ysv[i] = ((ys[i])).val[0] - u = acb_poly.__new__(acb_poly) - if algorithm == 'fast': - acb_poly_interpolate_fast((u).val, xsv, ysv, n, getprec()) - elif algorithm == 'newton': - acb_poly_interpolate_newton((u).val, xsv, ysv, n, getprec()) - else: - acb_poly_interpolate_barycentric((u).val, xsv, ysv, n, getprec()) - libc.stdlib.free(xsv) - libc.stdlib.free(ysv) - return u - - def derivative(self): - u = acb_poly.__new__(acb_poly) - acb_poly_derivative((u).val, (self).val, getprec()) - return u - - def integral(self): - u = acb_poly.__new__(acb_poly) - acb_poly_integral((u).val, (self).val, getprec()) - return u - - def __pos__(self): - return self # ? - - def __neg__(s): - u = acb_poly.__new__(acb_poly) - acb_poly_neg((u).val, (s).val) - return u - - def __add__(s, t): - if not isinstance(t, acb_poly): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - u = acb_poly.__new__(acb_poly) - acb_poly_add((u).val, (s).val, (t).val, getprec()) - return u - - def __radd__(s, t): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - if not isinstance(t, acb_poly): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - u = acb_poly.__new__(acb_poly) - acb_poly_sub((u).val, (s).val, (t).val, getprec()) - return u - - def __rsub__(s, t): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def __mul__(s, t): - if not isinstance(t, acb_poly): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - u = acb_poly.__new__(acb_poly) - acb_poly_mul((u).val, (s).val, (t).val, getprec()) - return u - - def __rmul__(s, t): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - def __floordiv__(s, t): - if not isinstance(t, acb_poly): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s // t - q = acb_poly.__new__(acb_poly) - r = acb_poly.__new__(acb_poly) - if acb_poly_divrem((q).val, (r).val, - (s).val, (t).val, getprec()): - return q - else: - raise ZeroDivisionError("acb_poly leading coefficient must be nonzero") - - def __rfloordiv__(s, t): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t // s - - def __mod__(s, t): - if not isinstance(t, acb_poly): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s % t - q = acb_poly.__new__(acb_poly) - r = acb_poly.__new__(acb_poly) - if acb_poly_divrem((q).val, (r).val, - (s).val, (t).val, getprec()): - return r - else: - raise ZeroDivisionError("acb_poly leading coefficient must be nonzero") - - def __rmod__(s, t): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t % s - - def __divmod__(s, t): - if not isinstance(t, acb_poly): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return divmod(s, t) - q = acb_poly.__new__(acb_poly) - r = acb_poly.__new__(acb_poly) - if acb_poly_divrem((q).val, (r).val, - (s).val, (t).val, getprec()): - return q, r - else: - raise ZeroDivisionError("acb_poly leading coefficient must be nonzero") - - def __rdivmod__(s, t): - s, t = acb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return divmod(t, s) - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then a copy of ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> f = acb_poly([1,2,3]) - >>> f.truncate(3) - 3.00000000000000*x^2 + 2.00000000000000*x + 1.00000000000000 - >>> f.truncate(2) - 2.00000000000000*x + 1.00000000000000 - >>> f.truncate(1) - 1.00000000000000 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - - """ - cdef acb_poly res - res = acb_poly.__new__(acb_poly) - - length = acb_poly_length(self.val) - if n <= 0: # return zero - return res - elif n > length: # do nothing - acb_poly_set(res.val, self.val) - else: - acb_poly_set_trunc(res.val, self.val, n) - - return res - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> f = acb_poly([1,2,3]) - >>> f.left_shift(0) - 3.00000000000000*x^2 + 2.00000000000000*x + 1.00000000000000 - >>> f.left_shift(1) - 3.00000000000000*x^3 + 2.00000000000000*x^2 + 1.00000000000000*x - >>> f.left_shift(4) - 3.00000000000000*x^6 + 2.00000000000000*x^5 + 1.00000000000000*x^4 - - """ - cdef acb_poly res - res = acb_poly.__new__(acb_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - acb_poly_shift_left(res.val, self.val, n) - else: # do nothing, just copy self - acb_poly_set(res.val, self.val) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> f = acb_poly([1,2,3]) - >>> f.right_shift(0) - 3.00000000000000*x^2 + 2.00000000000000*x + 1.00000000000000 - >>> f.right_shift(1) - 3.00000000000000*x + 2.00000000000000 - >>> f.right_shift(4) - 0 - """ - cdef acb_poly res - res = acb_poly.__new__(acb_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - acb_poly_shift_right(res.val, self.val, n) - else: # do nothing, just copy self - acb_poly_set(res.val, self.val) - - return res - - def __pow__(acb_poly s, ulong exp, mod): - if mod is not None: - raise NotImplementedError("acb_poly modular exponentiation") - u = acb_poly.__new__(acb_poly) - acb_poly_pow_ui((u).val, (s).val, exp, getprec()) - return u - - def __call__(s, t): - if typecheck(t, acb_poly): - u = acb_poly.__new__(acb_poly) - acb_poly_compose((u).val, (s).val, (t).val, getprec()) - return u - if typecheck(t, acb): - u = acb.__new__(acb) - acb_poly_evaluate((u).val, (s).val, (t).val, getprec()) - return u - if isinstance(t, (int, float, complex, fmpz, fmpq, arb)): - return s(acb(t)) - if isinstance(t, (fmpz_poly, fmpq_poly, arb_poly)): - return s(acb_poly(t)) - raise TypeError("cannot call acb_poly with input of type %s", type(t)) - - def unique_fmpz_poly(self): - u = fmpz_poly.__new__(fmpz_poly) - if acb_poly_get_unique_fmpz_poly((u).val, self.val): - return u - else: - return None - - def roots(s, tol=None, maxprec=None): - """ - Attempts to isolate all the complex roots of *s*. - If *tol* is specified, the roots are further refined - to at least the requested tolerance. - The input polynomial must be squarefree and sufficiently - accurate. Raises an exception if unsuccessful. - - >>> for c in acb_poly.from_roots([1,2,3,4,5]).roots(1e-10): print(float(c.real)) - ... - 1.0 - 2.0 - 3.0 - 4.0 - 5.0 - >>> for c in acb_poly.from_roots([1,2,2,4,5]).roots(1e-10): print(c) - ... - Traceback (most recent call last): - ... - ValueError: roots() failed to converge: insufficient precision, or squareful input - - """ - cdef long prec, initial_prec, isolated, maxiter, deg, i - cdef acb_ptr roots - cdef acb_poly_t tmp - deg = s.degree() - if deg < 0: - return [] - - roots = _acb_vec_init(deg) - acb_poly_init(tmp) - pyroots = [] - - try: - initial_prec = 32 - prec = initial_prec - - if maxprec is None: - maxprec = 2 * getprec() - - while 1: - maxiter = min(max(deg, 32), prec) - acb_poly_set_round(tmp, s.val, prec) - - if prec == initial_prec: - isolated = acb_poly_find_roots(roots, tmp, NULL, maxiter, prec) - else: - isolated = acb_poly_find_roots(roots, tmp, roots, maxiter, prec) - - if isolated == deg: - if tol is None: - break - elif acb_vec_check_tol(roots, deg, tol) == 1: - break - - prec *= 2 - - if prec > maxprec: - raise ValueError("roots() failed to converge: insufficient precision, or squareful input") - - _acb_vec_sort_pretty(roots, deg) - pyroots = [acb.__new__(acb) for i in range(deg)] - for i in range(deg): - acb_set(((pyroots[i])).val, &roots[i]) - - finally: - acb_poly_clear(tmp) - _acb_vec_clear(roots, deg) - - return pyroots - - complex_roots = roots - - def root_bound(self): - """Returns an upper bound for the absolute value of - the roots of self.""" - cdef mag_t m - mag_init(m) - r = arb() - acb_poly_root_bound_fujiwara(m, self.val) - arf_set_mag(arb_midref((r).val), m) - mag_clear(m) - return r diff --git a/src/flint/types/acb_series.pxd b/src/flint/types/acb_series.pxd deleted file mode 100644 index b34e14c5..00000000 --- a/src/flint/types/acb_series.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series - -from flint.flintlib.functions.acb_poly cimport acb_poly_t - -cdef class acb_series(flint_series): - cdef acb_poly_t val - cdef long _prec - cpdef long length(self) - cpdef valuation(self) diff --git a/src/flint/types/acb_series.pyx b/src/flint/types/acb_series.pyx deleted file mode 100644 index f7ddd895..00000000 --- a/src/flint/types/acb_series.pyx +++ /dev/null @@ -1,892 +0,0 @@ -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getprec, getcap -from flint.flint_base.flint_base cimport flint_series -from flint.types.fmpz_series cimport fmpz_series -from flint.types.fmpq_series cimport fmpq_series -from flint.types.arb_series cimport arb_series -from flint.types.acb cimport acb -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.arb_poly cimport arb_poly -from flint.types.acb_poly cimport acb_poly_set_list -from flint.types.arb cimport arb -from flint.types.acb_poly cimport acb_poly -from flint.types.dirichlet cimport dirichlet_char -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq -from flint.types.fmpz cimport any_as_fmpz -from flint.flintlib.functions.acb cimport * -from flint.flintlib.functions.acb_poly cimport * -from flint.flintlib.functions.acb_modular cimport * -from flint.flintlib.functions.acb_hypgeom cimport * -from flint.flintlib.functions.acb_dirichlet cimport * - -cimport cython -cimport libc.stdlib - -cdef acb_series_coerce_operands(x, y): - if isinstance(y, (int, float, complex, fmpz, fmpz_poly, fmpz_series, fmpq, fmpq_poly, fmpq_series, arb, arb_poly, arb_series, acb, acb_poly)): - return x, acb_series(y) - return NotImplemented, NotImplemented - -cdef class acb_series(flint_series): - """ - Arb series. - - >>> from flint import acb_series, ctx - >>> ctx.cap = 3 - >>> x = acb_series([0, 1]) - >>> x - 1.00000000000000*x + O(x^3) - >>> 1 / (1 + x) - 1.00000000000000 + (-1.00000000000000)*x + 1.00000000000000*x^2 + O(x^3) - >>> x.cos() - 1.00000000000000 + (-0.500000000000000)*x^2 + O(x^3) - - """ - - # cdef acb_poly_t val - # cdef long prec - - def __cinit__(self): - acb_poly_init(self.val) - self._prec = 0 - - def __dealloc__(self): - acb_poly_clear(self.val) - - def __init__(self, val=None, prec=None): - if prec is None: - self._prec = getcap() - else: - self._prec = prec - if self._prec < 0: - self._prec = -1 - if val is not None: - if typecheck(val, acb_series): - acb_poly_set(self.val, (val).val) - self._prec = min((val)._prec, getcap()) - elif typecheck(val, arb_series): - acb_poly_set_arb_poly(self.val, (val).val) - self._prec = min((val)._prec, getcap()) - elif typecheck(val, fmpz_series): - acb_poly_set_fmpz_poly(self.val, (val).val, getprec()) - self._prec = min((val)._prec, getcap()) - elif typecheck(val, fmpz_poly): - acb_poly_set_fmpz_poly(self.val, (val).val, getprec()) - elif typecheck(val, acb_poly): - acb_poly_set(self.val, (val).val) - elif typecheck(val, list): - acb_poly_set_list(self.val, val, getprec()) - else: - acb_poly_set_list(self.val, [val], getprec()) - acb_poly_truncate(self.val, max(0, self._prec)) - - @property - def prec(self): - """ - The precision of the finitely approximated power series. - - >>> from flint import acb_series, ctx - >>> ctx.cap = 10 - >>> a = acb_series([1,2,3]) - >>> a - 1.00000000000000 + 2.00000000000000*x + 3.00000000000000*x^2 + O(x^10) - >>> a.prec - 10 - >>> b = acb_series([1,2,3], prec=5) - >>> b - 1.00000000000000 + 2.00000000000000*x + 3.00000000000000*x^2 + O(x^5) - >>> b.prec - 5 - """ - return self._prec - - def __len__(self): - return acb_poly_length(self.val) - - cpdef long length(self): - return acb_poly_length(self.val) - - def __getitem__(self, long i): - cdef acb x - x = acb() - if i < 0: - return x - acb_poly_get_coeff_acb(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if not typecheck(x, acb): - x = acb(x) - acb_poly_set_coeff_acb(self.val, i, (x).val) - - def repr(self, **kwargs): - return "acb_series([%s], prec=%s)" % (", ".join(map(str, self)), self._prec) - - def str(self, *args, **kwargs): - if self._prec > 0: - s = acb_poly(list(self)).str(ascending=True, *args, **kwargs) - return s + (" + O(x^%s)" % self._prec) - elif self._prec == 0: - return "O(x^0)" - else: - return "(invalid power series)" - - def __pos__(self): - return self - - def __neg__(s): - cdef long cap - u = acb_series.__new__(acb_series) - cap = getcap() - cap = min(cap, (s)._prec) - if cap > 0: - acb_poly_neg((u).val, (s).val) - acb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __add__(s, t): - cdef long cap - if not isinstance(t, acb_series): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - - u = acb_series.__new__(acb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - acb_poly_add((u).val, (s).val, (t).val, getprec()) - acb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __radd__(s, t): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - cdef long cap - if not isinstance(t, acb_series): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - - u = acb_series.__new__(acb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - acb_poly_sub((u).val, (s).val, (t).val, getprec()) - acb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __rsub__(s, t): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def __mul__(s, t): - cdef long cap - if not isinstance(t, acb_series): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - - u = acb_series.__new__(acb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - acb_poly_mullow((u).val, (s).val, (t).val, cap, getprec()) - (u)._prec = cap - return u - - def __rmul__(s, t): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - cpdef valuation(self): - cdef long i - if self.length() == 0: - return -1 - i = 0 - while acb_is_zero(&(self.val.coeffs[i])): - i += 1 - return i - - def __truediv__(s, t): - cdef long cap, sval, tval - cdef acb_poly_t stmp, ttmp - - if not isinstance(t, acb_series): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s / t - - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - - if (t).length() == 0: - raise ZeroDivisionError("power series division") - - u = acb_series.__new__(acb_series) - - if (s).length() == 0: - u.cap = cap - return u - - sval = (s).valuation() - tval = (t).valuation() - - if sval < tval: - raise ValueError("quotient would not be a power series") - - if acb_contains_zero(&((t).val.coeffs[tval])): - raise ValueError("leading term in denominator is not nonzero") - - if tval == 0: - acb_poly_div_series((u).val, (s).val, (t).val, cap, getprec()) - else: - acb_poly_init(stmp) - acb_poly_init(ttmp) - acb_poly_shift_right(stmp, (s).val, tval) - acb_poly_shift_right(ttmp, (t).val, tval) - cap -= tval - acb_poly_div_series((u).val, stmp, ttmp, cap, getprec()) - acb_poly_clear(stmp) - acb_poly_clear(ttmp) - - (u)._prec = cap - return u - - def __rtruediv__(s, t): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t / s - - def __pow__(s, t, mod): - cdef long cap - if mod is not None: - raise NotImplementedError("modular exponentiation") - if not isinstance(t, acb_series): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s ** t - - u = acb_series.__new__(acb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - acb_poly_pow_series((u).val, (s).val, (t).val, cap, getprec()) - (u)._prec = cap - return u - - def __rpow__(s, t): - s, t = acb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t ** s - - def __call__(s, t): - cdef long cap - if typecheck(t, acb_series): - u = acb_series.__new__(acb_series) - if (t).valuation() < 1: - raise ValueError("power series composition with nonzero constant term") - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - acb_poly_compose_series((u).val, (s).val, (t).val, cap, getprec()) - (u)._prec = cap - return u - raise TypeError("cannot call acb_series with input of type %s", type(t)) - - def reversion(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if s.length() < 2 or (not acb_is_zero(&s.val.coeffs[0])) or \ - (acb_contains_zero(&s.val.coeffs[1])): - raise ValueError("power series reversion requires valuation 1") - u = acb_series.__new__(acb_series) - acb_poly_revert_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def inv(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if s.length() == 0: - raise ZeroDivisionError - u = acb_series.__new__(acb_series) - acb_poly_inv_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def derivative(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec - 1) - u = acb_series.__new__(acb_series) - acb_poly_derivative((u).val, (s).val, getprec()) - acb_poly_truncate((u).val, max(0, cap)) - (u)._prec = cap - return u - - def integral(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec + 1) - u = acb_series.__new__(acb_series) - acb_poly_integral((u).val, (s).val, getprec()) - acb_poly_truncate((u).val, max(0, cap)) - (u)._prec = cap - return u - - def sqrt(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_sqrt_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def rsqrt(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_rsqrt_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def exp(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_exp_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def log(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_log_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def atan(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_atan_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def sin(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_sin_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def cos(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_cos_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def sin_cos(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - v = acb_series.__new__(acb_series) - acb_poly_sin_cos_series((u).val, (v).val, (s).val, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - return u, v - - def sin_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_sin_pi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def cos_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_cos_pi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def sin_cos_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - v = acb_series.__new__(acb_series) - acb_poly_sin_cos_pi_series((u).val, (v).val, (s).val, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - return u, v - - def cot_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_cot_pi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def tan(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_tan_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def gamma(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_gamma_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def rgamma(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_rgamma_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def lgamma(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_lgamma_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def rising(s, ulong n): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_rising_ui_series((u).val, (s).val, n, cap, getprec()) - (u)._prec = cap - return u - - def zeta(s, a=1, bint deflate=0): - cdef long cap - a = acb(a) - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_zeta_series((u).val, (s).val, (a).val, deflate, cap, getprec()) - (u)._prec = cap - return u - - def dirichlet_l(s, chi, bint deflate=0): - cdef long cap - cdef dirichlet_char cchar - if isinstance(chi, dirichlet_char): - cchar = chi - else: - cchar = dirichlet_char(chi[0], chi[1]) - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_dirichlet_l_series((u).val, (s).val, cchar.G.val, cchar.val, deflate, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def polylog(cls, s, z): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - s = acb_series(s) - z = acb(z) - u = acb_series.__new__(acb_series) - acb_poly_polylog_series((u).val, (s).val, (z).val, cap, getprec()) - (u)._prec = cap - return u - - def agm(s, t=None): - cdef long cap - if t is None: - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_agm1_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - else: - return (s / t).agm() * t - - def elliptic_k(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_poly_elliptic_k_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def elliptic_p(s, tau): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - tau = acb(tau) - u = acb_series.__new__(acb_series) - acb_poly_elliptic_p_series((u).val, (s).val, (tau).val, cap, getprec()) - (u)._prec = cap - return u - - def erf(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_erf_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def erfc(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_erfc_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def erfi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_erfi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def gamma_upper(cls, s, z, int regularized=0): - cdef long cap - s = acb(s) - z = acb_series(z) - cap = getcap() - cap = min(cap, (z)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_gamma_upper_series((u).val, (s).val, (z).val, regularized, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def gamma_lower(cls, s, z, int regularized=0): - cdef long cap - s = acb(s) - z = acb_series(z) - cap = getcap() - cap = min(cap, (z)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_gamma_lower_series((u).val, (s).val, (z).val, regularized, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def beta_lower(cls, a, b, z, int regularized=0): - cdef long cap - a = acb(a) - b = acb(b) - z = acb_series(z) - cap = getcap() - cap = min(cap, (z)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_beta_lower_series((u).val, (a).val, (b).val, (z).val, regularized, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def hypgeom(cls, a, b, z, long n=-1, bint regularized=False): - r""" - Computes the generalized hypergeometric function `{}_pF_q(a;b;z)` - given lists of power series `a` and `b` and a power series `z`. - - The optional parameter *n*, if nonnegative, controls the number - of terms to add in the hypergeometric series. This is just a tuning - parameter: a rigorous error bound is computed regardless of *n*. - """ - cdef long i, p, q, cap - cdef acb_poly_struct * aa - cdef acb_poly_struct * bb - a = [acb_series(t) for t in a] - b = [acb_series(t) for t in b] + [acb_series(1)] # todo: remove from a if there - z = acb_series(z) - p = len(a) - q = len(b) - aa = libc.stdlib.malloc(p * cython.sizeof(acb_poly_struct)) - bb = libc.stdlib.malloc(q * cython.sizeof(acb_poly_struct)) - cap = getcap() - cap = min(cap, (z)._prec) - for i in range(p): - cap = min(cap, ((a[i]))._prec) - aa[i] = ((a[i])).val[0] - for i in range(q): - cap = min(cap, ((b[i]))._prec) - bb[i] = ((b[i])).val[0] - u = acb_series.__new__(acb_series) - acb_hypgeom_pfq_series_direct((u).val, aa, p, bb, q, (z).val, regularized, n, cap, getprec()) - libc.stdlib.free(aa) - libc.stdlib.free(bb) - (u)._prec = cap - return u - - def airy_ai(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_airy_series((u).val, NULL, NULL, NULL, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy_ai_prime(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_airy_series(NULL, (u).val, NULL, NULL, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy_bi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_airy_series(NULL, NULL, (u).val, NULL, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy_bi_prime(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_airy_series(NULL, NULL, NULL, (u).val, - (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - v = acb_series.__new__(acb_series) - w = acb_series.__new__(acb_series) - z = acb_series.__new__(acb_series) - acb_hypgeom_airy_series((u).val, (v).val, (w).val, (z).val, (s).val, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - (w)._prec = cap - (z)._prec = cap - return u, v, w, z - - def modular_theta(self, tau): - cdef long cap - tau = acb(tau) - cap = getcap() - cap = min(cap, (self)._prec) - t1 = acb_series.__new__(acb_series) - t2 = acb_series.__new__(acb_series) - t3 = acb_series.__new__(acb_series) - t4 = acb_series.__new__(acb_series) - acb_modular_theta_series((t1).val, (t2).val, (t3).val, (t4).val, (self).val, (tau).val, cap, getprec()) - (t1)._prec = cap - (t2)._prec = cap - (t3)._prec = cap - (t4)._prec = cap - return t1, t2, t3, t4 - - def coulomb(self, l, eta): - cdef long cap - l = acb(l) - eta = acb(eta) - cap = getcap() - cap = min(cap, (self)._prec) - F = acb_series.__new__(acb_series) - G = acb_series.__new__(acb_series) - Hpos = acb_series.__new__(acb_series) - Hneg = acb_series.__new__(acb_series) - acb_hypgeom_coulomb_series((F).val, (G).val, (Hpos).val, - (Hneg).val, (l).val, (eta).val, - (self).val, cap, getprec()) - (F)._prec = cap - (G)._prec = cap - (Hpos)._prec = cap - (Hneg)._prec = cap - return F, G, Hpos, Hneg - - def coulomb_f(self, l, eta): - cdef long cap - l = acb(l) - eta = acb(eta) - cap = getcap() - cap = min(cap, (self)._prec) - F = acb_series.__new__(acb_series) - acb_hypgeom_coulomb_series((F).val, NULL, NULL, NULL, - (l).val, (eta).val, (self).val, cap, getprec()) - (F)._prec = cap - return F - - def coulomb_g(self, l, eta): - cdef long cap - l = acb(l) - eta = acb(eta) - cap = getcap() - cap = min(cap, (self)._prec) - G = acb_series.__new__(acb_series) - acb_hypgeom_coulomb_series(NULL, (G).val, NULL, NULL, - (l).val, (eta).val, (self).val, cap, getprec()) - (G)._prec = cap - return G - - def fresnel(s, bint normalized=True): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - v = acb_series.__new__(acb_series) - acb_hypgeom_fresnel_series((u).val, (v).val, (s).val, normalized, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - return u, v - - def fresnel_s(s, bint normalized=True): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_fresnel_series((u).val, NULL, (s).val, normalized, cap, getprec()) - (u)._prec = cap - return u - - def fresnel_c(s, bint normalized=True): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_fresnel_series(NULL, (u).val, (s).val, normalized, cap, getprec()) - (u)._prec = cap - return u - - def ei(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_ei_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def si(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_si_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def ci(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_ci_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def shi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_shi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def chi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_chi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def li(s, bint offset=False): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = acb_series.__new__(acb_series) - acb_hypgeom_li_series((u).val, (s).val, offset, cap, getprec()) - (u)._prec = cap - return u - - def lambertw(s, branch=0): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - k = any_as_fmpz(branch) - u = acb_series.__new__(acb_series) - acb_poly_lambertw_series((u).val, (s).val, (k).val, 0, cap, getprec()) - (u)._prec = cap - return u diff --git a/src/flint/types/acb_theta.pyx b/src/flint/types/acb_theta.pyx deleted file mode 100644 index 80ed5df1..00000000 --- a/src/flint/types/acb_theta.pyx +++ /dev/null @@ -1,97 +0,0 @@ -from flint.flint_base.flint_context cimport getprec -from flint.types.acb cimport acb -from flint.types.acb_mat cimport acb_mat -from flint.flintlib.functions.acb cimport * -from flint.flintlib.types.acb cimport ( - acb_mat_entry, -) -from flint.flintlib.functions.acb_mat cimport * -from flint.flintlib.functions.acb_theta cimport * - - -def acb_theta(acb_mat z, acb_mat tau, ulong square=False): - r""" - Computes the vector valued Riemann theta function - `(\theta_{a,b}(z, \tau) : a, b \in \{0,1\}^{g})` or its squares. - - This is a wrapper for the C-function - `acb_theta_all `_ - and it follows the same conventions for the ordering of the theta characteristics. - - This should be used via the method :meth:`.acb_mat.theta`, explicitly ``tau.theta(z)``. - - >>> from flint import acb, acb_mat, showgood, ctx - >>> z = acb(1+1j); tau = acb(1.25+3j) - >>> t0, t1, t2, t3 = acb_mat([[tau]]).theta(acb_mat([[z]])).entries() - >>> all([abs(x) < 1e-13 for x in acb_mat([z.modular_theta(tau)]) - acb_mat([[-t3,t2,t0,t1]])]) - True - >>> showgood(lambda: acb_mat([[tau]]).theta(acb_mat([[z]])).transpose(), dps=25) - [0.9694430387796704100046143 - 0.03055696120816803328582847j] - [ 1.030556961196006476576271 + 0.03055696120816803328582847j] - [ -1.220790267576967690128359 - 1.827055516791154669091679j] - [ -1.820235910124989594900076 + 1.216251950154477951760042j] - >>> acb_mat([[1j,0],[0,2*1j]]).theta(acb_mat([[0],[0]])).transpose() # doctest: +SKIP - [ [1.09049252082308 +/- 5.07e-15] + [+/- 1.73e-15]j] - [ [1.08237710165638 +/- 5.64e-15] + [+/- 1.74e-15]j] - [ [0.91699125162112 +/- 4.17e-15] + [+/- 1.33e-15]j] - [ [0.91016702473556 +/- 3.01e-15] + [+/- 1.34e-15]j] - [[0.451696791791346 +/- 4.89e-16] + [+/- 1.86e-16]j] - [ [+/- 5.42e-16] + [+/- 5.42e-16]j] - [[0.379830212998946 +/- 3.47e-16] + [+/- 1.43e-16]j] - [ [+/- 4.62e-16] + [+/- 4.62e-16]j] - [ [0.91699125162112 +/- 6.83e-15] + [+/- 4.00e-15]j] - [ [0.91016702473556 +/- 5.70e-15] + [+/- 4.02e-15]j] - [ [+/- 2.44e-16] + [+/- 2.44e-16]j] - [ [+/- 2.45e-16] + [+/- 2.45e-16]j] - [[0.379830212998946 +/- 6.39e-16] + [+/- 4.35e-16]j] - [ [+/- 5.86e-16] + [+/- 5.86e-16]j] - [ [+/- 2.60e-17] + [+/- 2.60e-17]j] - [ [+/- 1.16e-16] + [+/- 1.16e-16]j] - >>> ctx.prec = 10000 - >>> print(acb_mat([[1j, 0],[0,1j]]).theta(acb_mat([[0],[0]])).transpose().str(25)) # doctest: +SKIP - [ [1.180340599016096226045338 +/- 5.95e-26] + [+/- 2.35e-3010]j] - [[0.9925441784910574194770081 +/- 3.15e-26] + [+/- 2.79e-3010]j] - [[0.9925441784910574194770081 +/- 3.15e-26] + [+/- 1.88e-3010]j] - [[0.8346268416740731862814297 +/- 3.29e-26] + [+/- 2.23e-3010]j] - [[0.9925441784910574194770081 +/- 3.15e-26] + [+/- 5.80e-3011]j] - [ [+/- 1.35e-3009] + [+/- 1.35e-3009]j] - [[0.8346268416740731862814297 +/- 3.29e-26] + [+/- 4.64e-3011]j] - [ [+/- 1.14e-3009] + [+/- 1.14e-3009]j] - [[0.9925441784910574194770081 +/- 3.15e-26] + [+/- 3.16e-3009]j] - [[0.8346268416740731862814297 +/- 3.29e-26] + [+/- 3.75e-3009]j] - [ [+/- 4.05e-3011] + [+/- 4.05e-3011]j] - [ [+/- 4.81e-3011] + [+/- 4.81e-3011]j] - [[0.8346268416740731862814297 +/- 3.29e-26] + [+/- 7.80e-3010]j] - [ [+/- 5.19e-3009] + [+/- 5.19e-3009]j] - [ [+/- 1.00e-3011] + [+/- 1.00e-3011]j] - [ [+/- 2.81e-3010] + [+/- 2.81e-3010]j] - >>> ctx.default() - - """ - g = tau.nrows() - assert tau.ncols() == g - assert z.nrows() == g - assert z.ncols() == 1 - - # convert input - cdef acb_ptr zvec - zvec = _acb_vec_init(g) - cdef long i - for i in range(g): - acb_set(zvec + i, acb_mat_entry(z.val, i, 0)) - - # initialize the output - cdef slong nb = 1 << (2 * g) - cdef acb_ptr theta = _acb_vec_init(nb) - - acb_theta_all(theta, zvec, tau.val, square, getprec()) - _acb_vec_clear(zvec, g) - # copy the output - res = [] - cdef acb r - for i in range(nb): - r = acb.__new__(acb) - acb_set(r.val, theta + i) - res.append(r) - _acb_vec_clear(theta, nb) - return acb_mat([res]) diff --git a/src/flint/types/arb.pxd b/src/flint/types/arb.pxd deleted file mode 100644 index 63728cfd..00000000 --- a/src/flint/types/arb.pxd +++ /dev/null @@ -1,19 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar - -from flint.flintlib.functions.arb cimport arb_t - -cdef any_as_arb_or_notimplemented(x) -cdef int arb_set_python(arb_t x, obj, bint allow_conversion) except -1 -cdef any_as_arb(x) -cdef arb_set_mpmath_mpf(arb_t x, obj) - -cdef class arb(flint_scalar): - cdef arb_t val - - cpdef bint is_zero(self) - cpdef bint is_finite(self) - cpdef bint is_nan(self) - cpdef bint is_exact(self) - cpdef bint is_integer(self) - - cdef tuple _to_arfs(self) diff --git a/src/flint/types/arb.pyx b/src/flint/types/arb.pyx deleted file mode 100644 index dbb5c066..00000000 --- a/src/flint/types/arb.pyx +++ /dev/null @@ -1,2715 +0,0 @@ -from cpython.float cimport PyFloat_AsDouble -from cpython.long cimport PyLong_Check - -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_context cimport thectx -from flint.flint_base.flint_base cimport flint_scalar -from flint.utils.typecheck cimport typecheck -from flint.utils.conversion cimport chars_from_str, str_from_chars -from flint.types.fmpz cimport fmpz_set_pylong -from flint.types.arf cimport arf -from flint.types.fmpq cimport fmpq -from flint.types.fmpz cimport fmpz - -from flint.flintlib.types.flint cimport FMPZ_UNKNOWN, FMPZ_TMP, FMPZ_REF -from flint.flintlib.functions.flint cimport flint_free -from flint.flintlib.functions.mag cimport * -from flint.flintlib.functions.fmpz cimport fmpz_init, fmpz_clear -from flint.flintlib.functions.arf cimport * -from flint.flintlib.types.arf cimport ARF_RND_NEAR, ARF_RND_DOWN -from flint.flintlib.functions.arb cimport * -from flint.flintlib.types.arb cimport ( - arb_struct, - arb_midref, - arb_radref, - ARB_STR_NO_RADIUS, - ARB_STR_MORE, - ARB_STR_CONDENSE, -) -from flint.flintlib.functions.arb_hypgeom cimport * -from flint.flintlib.functions.acb_dirichlet cimport * - -cimport libc.stdlib -cimport cython - -ctx = thectx - -# cdef _str_trunc(s, trunc=0): -# if trunc > 0 and len(s) > 3 * trunc: -# left = right = trunc -# omitted = len(s) - left - right -# return s[:left] + ("{...%s digits...}" % omitted) + s[-right:] -# return s - -cdef arb_from_str(str s): - s = s.strip() - if ("/" in s) and ("+/-" not in s): - return arb(fmpq(s)) - s = s.replace("±", "+/-") - a = arb.__new__(arb) - if arb_set_str((a).val, chars_from_str(s), getprec()) == 0: - return a - else: - raise ValueError("invalid string for arb()") - -cdef arb_set_mpmath_mpf(arb_t x, obj): - sgn, man, exp, _ = obj - - if not man: - if not exp: - arb_zero(x) - else: - arb_indeterminate(x) - else: - man = fmpz(int(man)) - exp = fmpz(exp) - - arb_set_fmpz(x, (man).val) - arb_mul_2exp_fmpz(x, x, (exp).val) - - if sgn: - arb_neg(x, x) - -cdef int arb_set_python(arb_t x, obj, bint allow_conversion) except -1: - """ - Sets an arb_t given any Python object. If allow_conversion is set, - conversions for the arb() constructor are done (from tuples, strings, etc.) - """ - cdef fmpz_t t - - if typecheck(obj, arb): - arb_set(x, (obj).val) - return 1 - - if typecheck(obj, arf): - arb_set_arf(x, (obj).val) - return 1 - - if typecheck(obj, fmpz): - arb_set_fmpz(x, (obj).val) - return 1 - - if typecheck(obj, fmpq): - arb_set_fmpq(x, (obj).val, getprec()) - return 1 - - if PyLong_Check(obj): - fmpz_init(t) - fmpz_set_pylong(t, obj) - arb_set_fmpz(x, t) - fmpz_clear(t) - return 1 - - if typecheck(obj, float): - arf_set_d(arb_midref(x), PyFloat_AsDouble(obj)) - mag_zero(arb_radref(x)) - return 1 - - if hasattr(obj, "_mpf_"): - arb_set_mpmath_mpf(x, obj._mpf_) - return 1 - - if allow_conversion and typecheck(obj, tuple): - v = arf(obj) - arb_set_arf(x, (v).val) - return 1 - - if allow_conversion and typecheck(obj, str): - obj = arb_from_str(obj) - arb_set(x, (obj).val) - return 1 - - return 0 - -cdef inline int arb_set_any_ref(arb_t x, obj): - if typecheck(obj, arb): - x[0] = (obj).val[0] - return FMPZ_REF - arb_init(x) - if arb_set_python(x, obj, 0): - return FMPZ_TMP - return FMPZ_UNKNOWN - -cdef any_as_arb(x): - cdef arb t - if typecheck(x, arb): - return x - t = arb() - if arb_set_python(t.val, x, 0) == 0: - raise TypeError("cannot create arb from type %s" % type(x)) - return t - -cdef any_as_arb_or_notimplemented(x): - cdef arb t - if typecheck(x, arb): - return x - t = arb() - if arb_set_python(t.val, x, 0) == 0: - return NotImplemented - return t - -cdef class arb(flint_scalar): - r""" - Represents a real number `x` by a midpoint `m` and a radius `r` - such that `x \in [m \pm r] = [m-r, m+r]`. - The midpoint and radius are both floating-point numbers. The radius - uses a fixed, implementation-defined precision (30 bits). - The precision used for midpoints is controlled by :attr:`ctx.prec` (bits) - or equivalently :attr:`ctx.dps` (digits). - - The constructor accepts a midpoint *mid* and a radius *rad*, either of - which defaults to zero if omitted. The arguments can be tuples - `(a, b)` representing exact floating-point data `a 2^b`, integers, - floating-point numbers, rational strings, or decimal strings. - If the radius is nonzero, it might be rounded up to a slightly larger - value than the exact value passed by the user. - - >>> arb(10.25) - 10.2500000000000 - >>> print(1 / arb(4)) # exact - 0.250000000000000 - >>> print(1 / arb(3)) # approximate - [0.333333333333333 +/- 3.71e-16] - >>> print(arb("3.0")) - 3.00000000000000 - >>> print(arb("0.1")) # doctest: +SKIP - [0.100000000000000 +/- 2.23e-17] - >>> print(arb("1/10")) # doctest: +SKIP - [0.100000000000000 +/- 2.23e-17] - >>> print(arb("3.14159 +/- 0.00001")) - [3.1416 +/- 2.01e-5] - >>> ctx.dps = 50 - >>> print(arb("1/3")) - [0.33333333333333333333333333333333333333333333333333 +/- 3.78e-51] - >>> ctx.default() - - Converting to or from decimal results in some loss of accuracy. - See :meth:`.arb.str` for details. - """ - - # cdef arb_t val - - def __cinit__(self): - arb_init(self.val) - - def __dealloc__(self): - arb_clear(self.val) - - def __init__(self, mid=None, rad=None): - cdef arf _rad - cdef fmpz man, exp - if mid is not None: - if arb_set_python(self.val, mid, 1) == 0: - raise TypeError("cannot create arb from type %s" % type(mid)) - if rad is not None: - if isinstance(rad, tuple): - # Set the radius exactly from tuple of ints so that - # eval(a.repr()) round trips. - _rad = arf(rad) - man, exp = _rad.man_exp() - mag_set_fmpz_2exp_fmpz(arb_radref(self.val), man.val, exp.val) - else: - rad = arb(rad) - arb_add_error(self.val, (rad).val) - - cpdef bint is_zero(self): - return arb_is_zero(self.val) - - cpdef bint is_finite(self): - return arb_is_finite(self.val) - - cpdef bint is_nan(self): - return arf_is_nan(arb_midref(self.val)) - - cpdef bint is_exact(self): - return arb_is_exact(self.val) - - def man_exp(self): - """ - Decomposes *self* into an integer mantissa and an exponent, - returning an *fmpz* pair. Requires that *self* is exact - and finite. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> arb("1.1").mid().man_exp() # doctest: +SKIP - (4953959590107545, -52) - >>> arb("1.1").rad().man_exp() # doctest: +SKIP - (1, -52) - >>> arb(0).man_exp() - (0, 0) - >>> arb("1.1").man_exp() - Traceback (most recent call last): - ... - ValueError: man_exp requires an exact, finite value - >>> arb("+inf").man_exp() - Traceback (most recent call last): - ... - ValueError: man_exp requires an exact, finite value - """ - cdef fmpz man, exp - if not self.is_finite() or not self.is_exact(): - raise ValueError("man_exp requires an exact, finite value") - man = fmpz() - exp = fmpz() - arf_get_fmpz_2exp(man.val, exp.val, arb_midref(self.val)) - return man, exp - - def fmpq(self): - cdef fmpq res - if not self.is_finite() or not self.is_exact(): - raise ValueError("fmpq requires an exact, finite value") - res = fmpq() - arf_get_fmpq(res.val, arb_midref(self.val)) - return res - - def fmpz(self): - cdef fmpz res - if not self.is_integer(): - raise ValueError("fmpz requires an exact, integer value") - res = fmpz() - arf_get_fmpz(res.val, arb_midref(self.val), ARF_RND_DOWN) - return res - - cpdef bint is_integer(self): - return arb_is_int(self.val) - - def mid(self): - """ - Returns the midpoint of *self* as an exact *arb*: - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> arb("1 +/- 0.3").mid() - 1.00000000000000 - """ - cdef arb x = arb() - arf_set(arb_midref(x.val), arb_midref(self.val)) - return x - - def rad(self): - """ - Returns the radius of *self* as an exact *arb*: - - >>> print(arb("1 +/- 0.3").rad().str(5, radius=False)) - 0.30000 - """ - cdef arb x = arb() - arf_set_mag(arb_midref(x.val), arb_radref(self.val)) - return x - - def abs_lower(self): - """ - Lower bound for the absolute value of *self*. - The output is an *arb* holding an exact floating-point number - that has been rounded down to the current precision. - - >>> print(arb("-5 +/- 2").abs_lower().str(5, radius=False)) - 3.0000 - """ - cdef arb x = arb() - arb_get_abs_lbound_arf(arb_midref(x.val), self.val, getprec()) - return x - - def abs_upper(self): - """ - Upper bound for the absolute value of *self*. - The output is an *arb* holding an exact floating-point number - that has been rounded up to the current precision. - - >>> print(arb("-5 +/- 2").abs_upper().str(5, radius=False)) - 7.0000 - """ - cdef arb x = arb() - arb_get_abs_ubound_arf(arb_midref(x.val), self.val, getprec()) - return x - - def lower(self): - r""" - Lower bound for *self* (towards `-\infty`). - The output is an *arb* holding an exact floating-point number - that has been rounded down to the current precision. - - >>> print(arb("-5 +/- 2").lower().str(5, radius=False)) - -7.0000 - """ - cdef arb x = arb() - arb_get_lbound_arf(arb_midref(x.val), self.val, getprec()) - return x - - def upper(self): - r""" - Upper bound for *self* (towards `+\infty`). - The output is an *arb* holding an exact floating-point number - that has been rounded up to the current precision. - - >>> print(arb("-5 +/- 2").upper().str(5, radius=False)) - -3.0000 - """ - cdef arb x = arb() - arb_get_ubound_arf(arb_midref(x.val), self.val, getprec()) - return x - - def mid_rad_10exp(self, long n=0): - r""" - Returns an *fmpz* triple (*mid*, *rad*, *exp*) where the larger of *mid* - and *rad* has *n* digits plus a few digits (*n* defaults to the current - precision), such that *self* is contained in - `[\operatorname{mid} \pm \operatorname{rad}] 10^{\operatorname{exp}}`. - - >>> (arb(1) / 3).mid_rad_10exp(10) - (333333333333333, 2, -15) - >>> (arb(1) / 3).mid_rad_10exp(20) - (3333333333333333148296162, 555111516, -25) - >>> arb(0,1e-100).mid_rad_10exp(10) - (0, 100000000376832, -114) - >>> arb(-1,1e100).mid_rad_10exp() - (0, 10000000083585662976, 81) - - """ - cdef fmpz mid, rad, exp - if n <= 0: - n = ctx.dps - mid = fmpz() - rad = fmpz() - exp = fmpz() - arb_get_fmpz_mid_rad_10exp(mid.val, rad.val, exp.val, self.val, n) - return mid, rad, exp - - @property - def _mpf_(self): - try: - import mpmath - mpmath_mpz = mpmath.libmp.MPZ - except ImportError: - mpmath_mpz = int - if not self.is_finite(): - return (0, mpmath_mpz(0), -123, -1) - man, exp = self.mid().man_exp() - man = mpmath_mpz(int(man)) - if man < 0: - return (1, -man, int(exp), man.bit_length()) - else: - return (0, man, int(exp), man.bit_length()) - - # Make this a public function? - cdef tuple _to_arfs(self): - cdef arf mid = arf.__new__(arf) - cdef arf rad = arf.__new__(arf) - arf_set(mid.val, arb_midref(self.val)) - arf_set_mag(rad.val, arb_radref(self.val)) - return (mid, rad) - - def repr(self): - mid, rad = self._to_arfs() - if rad.is_zero() or mid.is_nan(): - return "arb(%s)" % mid._repr_str() - else: - return "arb(%s, %s)" % (mid._repr_str(), rad._repr_str()) - - def str(self, long n=0, bint radius=True, bint more=False, long condense=0): - ur""" - Produces a human-readable decimal representation of self, with - up to *n* printed digits (which defaults to the current precision) - for the midpoint. The output can be parsed by the *arb* constructor. - - Since the internal representation is binary, conversion - to decimal (and back from decimal) is generally inexact. - Binary-decimal-binary roundtrips may result in significantly - larger intervals, and should therefore be done sparingly. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> print(arb.pi().str()) - [3.14159265358979 +/- 3.34e-15] - >>> print(arb.pi().str(5)) - [3.1416 +/- 7.35e-6] - >>> print(arb.pi().str(5, radius=False)) - 3.1416 - - By default, the output is truncated so that all displayed digits - are guaranteed to be correct, up to adding or subtracting 1 in the - last displayed digit (as a special case, if the output ends with a - string of 0s, the correct decimal expansion to infinite precision - could have a string of 9s). - - >>> print((arb(1) - arb("1e-10")).str(5)) - [1.0000 +/- 4e-10] - >>> print((arb(1) - arb("1e-10")).str(10)) - [0.9999999999 +/- 3e-15] - - To force more digits, set *more* to *True*. - - >>> print(arb("0.1").str(30)) # doctest: +SKIP - [0.100000000000000 +/- 2.23e-17] - >>> print(arb("0.1").str(30, more=True)) # doctest: +SKIP - [0.0999999999999999916733273153113 +/- 1.39e-17] - - Note that setting *more* to *True* results in a smaller printed radius, - since there is less error from the conversion back to decimal. - - >>> x = arb.pi().sin() - >>> print(x.str()) - [+/- 3.46e-16] - >>> print(x.str(more=True)) - [1.22460635382238e-16 +/- 2.23e-16] - - The error indicated in the output may be much larger than the actual - error in the internal representation of *self*. For example, if *self* - is accurate to 1000 digits and printing is done at 10-digit precision, - the output might only appear as being accurate to 10 digits. It is - even possible for *self* to be exact and have an inexact decimal - representation. - - The *condense* option can be passed to show only leading and trailing - digits of the fractional, integer and exponent parts of the output. - - >>> ctx.dps = 1000 - >>> print(arb.pi().str(condense=10)) - [3.1415926535{...979 digits...}9216420199 +/- 9.28e-1001] - >>> print(arb.fac_ui(300).str(condense=10)) - 3060575122{...595 digits...}0000000000.0000000000{...365 digits...}0000000000 - >>> print(arb(10**100).exp().str(condense=5)) - [1.53837{...989 digits...}96534e+43429{...90 digits...}17483 +/- 4.84e+43429{...90 digits...}16483] - >>> ctx.default() - - """ - cdef ulong flags - cdef char * s - flags = 0 - if not radius: - flags |= ARB_STR_NO_RADIUS - if more: - flags |= ARB_STR_MORE - if condense > 0: - flags |= ARB_STR_CONDENSE * condense - if n <= 0: - n = ctx.dps - s = arb_get_str(self.val, n, flags) - try: - res = str_from_chars(s) - finally: - flint_free(s) - if ctx.unicode: - res = res.replace("+/-", "±") - return res - - def __float__(self): - return arf_get_d(arb_midref(self.val), ARF_RND_NEAR) - - def __richcmp__(s, t, int op): - cdef bint res - cdef arb_struct sval[1] - cdef arb_struct tval[1] - cdef int stype, ttype - stype = arb_set_any_ref(sval, s) - if stype == FMPZ_UNKNOWN: - return NotImplemented - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - res = 0 - if op == 2: - res = arb_eq(sval, tval) - elif op == 3: - res = arb_ne(sval, tval) - elif op == 0: - res = arb_lt(sval, tval) - elif op == 1: - res = arb_le(sval, tval) - elif op == 4: - res = arb_gt(sval, tval) - elif op == 5: - res = arb_ge(sval, tval) - if stype == FMPZ_TMP: - arb_clear(sval) - if ttype == FMPZ_TMP: - arb_clear(tval) - return res - - def __hash__(self): - """Hash.""" - if self.is_exact(): - return hash((self.mid().man_exp(), self.rad().man_exp())) - raise ValueError(f"Cannot hash non-exact arb: {self}. See pull/341 for details.") - - def __contains__(self, other): - other = any_as_arb(other) - return arb_contains(self.val, (other).val) - - def contains(self, other): - other = any_as_arb(other) - return bool(arb_contains(self.val, (other).val)) - - def contains_interior(self, other): - other = any_as_arb(other) - return bool(arb_contains_interior(self.val, (other).val)) - - def overlaps(self, other): - other = any_as_arb(other) - return bool(arb_overlaps((self).val, (other).val)) - - def contains_integer(self): - return bool(arb_contains_int(self.val)) - - @property - def real(self): - return self - - @property - def imag(self): - return arb() - - def __pos__(self): - res = arb.__new__(arb) - arb_set_round((res).val, (self).val, getprec()) - return res - - def __neg__(self): - res = arb.__new__(arb) - arb_neg_round((res).val, (self).val, getprec()) - return res - - def neg(self, bint exact=False): - res = arb.__new__(arb) - if exact: - arb_neg((res).val, (self).val) - else: - arb_neg_round((res).val, (self).val, getprec()) - return res - - def __abs__(self): - res = arb.__new__(arb) - arb_abs((res).val, (self).val) - arb_set_round((res).val, (res).val, getprec()) - return res - - def sgn(self): - """ - Sign function, returning an *arb*. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> arb(-3).sgn() - -1.00000000000000 - >>> arb(0).sgn() - 0 - >>> arb("0 +/- 1").sgn() - [+/- 1.01] - """ - res = arb.__new__(arb) - arb_sgn((res).val, (self).val) - return res - - def __add__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_add((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __radd__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_add((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __sub__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_sub((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __rsub__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_sub((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __mul__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_mul((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __rmul__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_mul((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __truediv__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_div((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __rtruediv__(s, t): - cdef arb_struct tval[1] - cdef int ttype - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_div((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __pow__(s, t, modulus): - cdef arb_struct tval[1] - cdef int ttype - if modulus is not None: - raise TypeError("three-argument pow() not supported by arb type") - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_pow((u).val, (s).val, tval, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def __rpow__(s, t, modulus): - cdef arb_struct tval[1] - cdef int ttype - if modulus is not None: - raise TypeError("three-argument pow() not supported by arb type") - ttype = arb_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = arb.__new__(arb) - arb_pow((u).val, tval, s.val, getprec()) - if ttype == FMPZ_TMP: - arb_clear(tval) - return u - - def floor(s): - r""" - Floor function `\lfloor s \rfloor`. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> print(arb.pi().floor()) - 3.00000000000000 - >>> print((arb.pi() - arb.pi()).floor().str(more=True)) - [-0.500000000000000 +/- 0.501] - """ - u = arb.__new__(arb) - arb_floor((u).val, (s).val, getprec()) - return u - - def ceil(s): - r""" - Ceiling function `\lceil s \rceil`. - - >>> print(arb.pi().ceil()) - 4.00000000000000 - >>> print((arb.pi() - arb.pi()).ceil().str(more=True)) - [0.500000000000000 +/- 0.501] - """ - u = arb.__new__(arb) - arb_ceil((u).val, (s).val, getprec()) - return u - - def sqrt(s): - r""" - Square root `\sqrt{s}`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).sqrt(), dps=25) - 1.732050807568877293527446 - >>> showgood(lambda: arb(0).sqrt(), dps=25) - 0 - >>> showgood(lambda: arb(-1).sqrt(), dps=25) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - - This function is undefined for negative input. - Use :meth:`.acb.sqrt` for the complex extension. - """ - u = arb.__new__(arb) - arb_sqrt((u).val, (s).val, getprec()) - return u - - def rsqrt(s): - r""" - Reciprocal square root `1/\sqrt{s}`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).rsqrt(), dps=25) - 0.5773502691896257645091488 - >>> showgood(lambda: arb(0).rsqrt(), dps=25) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - >>> showgood(lambda: arb(-1).rsqrt(), dps=25) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - - This function is undefined for negative input. - Use :meth:`.acb.rsqrt` for the complex extension. - """ - u = arb.__new__(arb) - arb_rsqrt((u).val, (s).val, getprec()) - return u - - def exp(s): - r""" - Exponential function `\exp(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).exp(), dps=25) - 2.718281828459045235360287 - """ - u = arb.__new__(arb) - arb_exp((u).val, (s).val, getprec()) - return u - - def expm1(s): - r""" - Exponential function `\exp(s) - 1`, computed accurately for small *s*. - - >>> from flint import showgood - >>> showgood(lambda: (arb(10) ** -8).expm1(), dps=25) - 1.000000005000000016666667e-8 - """ - u = arb.__new__(arb) - arb_expm1((u).val, (s).val, getprec()) - return u - - def log(s): - r""" - Natural logarithm `\log(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(2).log(), dps=25) - 0.6931471805599453094172321 - >>> showgood(lambda: arb(100).exp().log(), dps=25) - 100.0000000000000000000000 - >>> showgood(lambda: arb(-1).sqrt(), dps=25) - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - - This function is undefined for negative input. - Use :meth:`.acb.log` for the complex extension. - """ - u = arb.__new__(arb) - arb_log((u).val, (s).val, getprec()) - return u - - def log1p(s): - r""" - Natural logarithm `\log(1+s)`, computed accurately for small *s*. - - >>> from flint import showgood - >>> from flint import acb - >>> showgood(lambda: acb(1).log1p(), dps=25) - 0.6931471805599453094172321 - >>> showgood(lambda: arb("1e-100000000000000000").log1p(), dps=25) - 1.000000000000000000000000e-100000000000000000 - - This function is undefined for `s \le -1`. - Use :meth:`.acb.log1p` for the complex extension. - """ - u = arb.__new__(arb) - arb_log1p((u).val, (s).val, getprec()) - return u - - def log_base(s, ulong b): - r""" - Returns `\log_b(s)`, computed exactly when possible. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> arb(2048).log_base(2) - 11.0000000000000 - """ - u = arb.__new__(arb) - arb_log_base_ui((u).val, (s).val, b, getprec()) - return u - - def sin(s): - r""" - Sine function `\sin(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).sin(), dps=25) - 0.8414709848078965066525023 - """ - u = arb.__new__(arb) - arb_sin((u).val, (s).val, getprec()) - return u - - def cos(s): - r""" - Cosine function `\cos(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).cos(), dps=25) - 0.5403023058681397174009366 - """ - u = arb.__new__(arb) - arb_cos((u).val, (s).val, getprec()) - return u - - def sin_cos(s): - r""" - Computes `\sin(s)` and `\cos(s)` simultaneously. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).sin_cos(), dps=25) - (0.8414709848078965066525023, 0.5403023058681397174009366) - """ - u = arb.__new__(arb) - v = arb.__new__(arb) - arb_sin_cos((u).val, (v).val, (s).val, getprec()) - return u, v - - def sin_pi(s): - r""" - Sine function `\sin(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(0.75).sin_pi(), dps=25) - 0.7071067811865475244008444 - >>> showgood(lambda: arb(1).sin_pi(), dps=25) - 0 - """ - u = arb.__new__(arb) - arb_sin_pi((u).val, (s).val, getprec()) - return u - - def cos_pi(s): - r""" - Cosine function `\cos(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(0.75).cos_pi(), dps=25) - -0.7071067811865475244008444 - >>> showgood(lambda: arb(0.5).cos_pi(), dps=25) - 0 - """ - u = arb.__new__(arb) - arb_cos_pi((u).val, (s).val, getprec()) - return u - - def sin_cos_pi(s): - r""" - Computes `\sin(\pi s)` and `\cos(\pi s)` simultaneously. - - >>> from flint import showgood - >>> showgood(lambda: arb(0.75).sin_cos_pi(), dps=25) - (0.7071067811865475244008444, -0.7071067811865475244008444) - """ - u = arb.__new__(arb) - v = arb.__new__(arb) - arb_sin_cos_pi((u).val, (v).val, (s).val, getprec()) - return u, v - - def tan(s): - r""" - Tangent function `\tan(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).tan(), dps=25) - 1.557407724654902230506975 - """ - u = arb.__new__(arb) - arb_tan((u).val, (s).val, getprec()) - return u - - def cot(s): - r""" - Cotangent function `\cot(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).cot(), dps=25) - 0.6420926159343307030064200 - """ - u = arb.__new__(arb) - arb_cot((u).val, (s).val, getprec()) - return u - - def tan_pi(s): - r""" - Tangent function `\tan(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(0.125).tan_pi(), dps=25) - 0.4142135623730950488016887 - >>> showgood(lambda: arb(1).tan_pi(), dps=25) - 0 - """ - u = arb.__new__(arb) - arb_tan_pi((u).val, (s).val, getprec()) - return u - - def cot_pi(s): - r""" - Cotangent function `\cot(\pi s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(0.125).cot_pi(), dps=25) - 2.414213562373095048801689 - >>> showgood(lambda: arb(0.5).cot_pi(), dps=25) - 0 - """ - u = arb.__new__(arb) - arb_cot_pi((u).val, (s).val, getprec()) - return u - - @staticmethod - def sin_pi_fmpq(fmpq s): - r""" - Returns the algebraic sine value `\sin(\pi s)`. - - >>> from flint import fmpq - >>> from flint import showgood - >>> showgood(lambda: arb.sin_pi_fmpq(fmpq(3,4)), dps=25) - 0.7071067811865475244008444 - """ - u = arb.__new__(arb) - arb_sin_pi_fmpq((u).val, (s).val, getprec()) - return u - - @staticmethod - def cos_pi_fmpq(fmpq s): - r""" - Returns the algebraic cosine value `\cos(\pi s)`. - - >>> from flint import fmpq - >>> from flint import showgood - >>> showgood(lambda: arb.cos_pi_fmpq(fmpq(3,4)), dps=25) - -0.7071067811865475244008444 - """ - u = arb.__new__(arb) - arb_cos_pi_fmpq((u).val, (s).val, getprec()) - return u - - @staticmethod - def sin_cos_pi_fmpq(fmpq s): - r""" - Computes `\sin(\pi s)` and `\cos(\pi s)` simultaneously. - - >>> from flint import fmpq - >>> from flint import showgood - >>> showgood(lambda: arb.sin_cos_pi_fmpq(fmpq(3,4)), dps=25) - (0.7071067811865475244008444, -0.7071067811865475244008444) - """ - u = arb.__new__(arb) - v = arb.__new__(arb) - arb_sin_cos_pi_fmpq((u).val, (v).val, (s).val, getprec()) - return u, v - - def sec(s): - r""" - Secant function `\operatorname{sec}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).sec(), dps=25) - 1.850815717680925617911753 - """ - u = arb.__new__(arb) - arb_sec((u).val, (s).val, getprec()) - return u - - def csc(s): - r""" - Cosecant function `\operatorname{csc}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).csc(), dps=25) - 1.188395105778121216261599 - """ - u = arb.__new__(arb) - arb_csc((u).val, (s).val, getprec()) - return u - - def sinc(s): - r""" - Sinc function, `\operatorname{sinc}(x) = \sin(x)/x`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).sinc(), dps=25) - 0.04704000268662240736691493 - """ - u = arb.__new__(arb) - arb_sinc((u).val, (s).val, getprec()) - return u - - def sinc_pi(s): - r""" - Normalized sinc function, `\operatorname{sinc}(\pi x) = \sin(\pi x)/(\pi x)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1.5).sinc_pi(), dps=25) - -0.2122065907891937810251784 - >>> showgood(lambda: arb(2).sinc_pi(), dps=25) - 0 - """ - u = arb.__new__(arb) - arb_sinc_pi((u).val, (s).val, getprec()) - return u - - def atan(s): - r""" - Inverse tangent `\operatorname{atan}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).atan(), dps=25) - 0.7853981633974483096156608 - """ - u = arb.__new__(arb) - arb_atan((u).val, (s).val, getprec()) - return u - - @staticmethod - def atan2(s, t): - r""" - Two-argument inverse tangent `\operatorname{atan2}(s,t)`. - - >>> from flint import showgood - >>> showgood(lambda: arb.atan2(-10,-5), dps=25) - -2.034443935795702735445578 - """ - s = any_as_arb(s) - t = any_as_arb(t) - u = arb.__new__(arb) - arb_atan2((u).val, (s).val, (t).val, getprec()) - return u - - def acos(s): - r""" - Inverse cosine `\operatorname{acos}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(0).acos(), dps=25) - 1.570796326794896619231322 - """ - u = arb.__new__(arb) - arb_acos((u).val, (s).val, getprec()) - return u - - def asin(s): - r""" - Inverse sine `\operatorname{asin}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).asin(), dps=25) - 1.570796326794896619231322 - """ - u = arb.__new__(arb) - arb_asin((u).val, (s).val, getprec()) - return u - - def atanh(s): - r""" - Inverse hyperbolic tangent `\operatorname{atanh}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb("0.99").atanh(), dps=25) - 2.646652412362246197705061 - """ - u = arb.__new__(arb) - arb_atanh((u).val, (s).val, getprec()) - return u - - def asinh(s): - r""" - Inverse hyperbolic sine `\operatorname{asinh}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1000).asinh(), dps=25) - 7.600902709541988611523290 - """ - u = arb.__new__(arb) - arb_asinh((u).val, (s).val, getprec()) - return u - - def acosh(s): - r""" - Inverse hyperbolic cosine `\operatorname{acosh}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(2).acosh(), dps=25) - 1.316957896924816708625046 - """ - u = arb.__new__(arb) - arb_acosh((u).val, (s).val, getprec()) - return u - - def sinh(s): - r""" - Hyperbolic sine `\sinh(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).sinh(), dps=25) - 1.175201193643801456882382 - """ - u = arb.__new__(arb) - arb_sinh((u).val, (s).val, getprec()) - return u - - def cosh(s): - r""" - Hyperbolic cosine `\cosh(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).cosh(), dps=25) - 1.543080634815243778477906 - """ - u = arb.__new__(arb) - arb_cosh((u).val, (s).val, getprec()) - return u - - def sinh_cosh(s): - r""" - Computes `\sinh(s)` and `\cosh(s)` simultaneously. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).sinh_cosh(), dps=25) - (1.175201193643801456882382, 1.543080634815243778477906) - """ - u = arb.__new__(arb) - v = arb.__new__(arb) - arb_sinh_cosh((u).val, (v).val, (s).val, getprec()) - return u, v - - def tanh(s): - r""" - Hyperbolic tangent `\tanh(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).tanh(), dps=25) - 0.7615941559557648881194583 - """ - u = arb.__new__(arb) - arb_tanh((u).val, (s).val, getprec()) - return u - - def coth(s): - r""" - Hyperbolic cotangent `\coth(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).coth(), dps=25) - 1.313035285499331303636161 - """ - u = arb.__new__(arb) - arb_coth((u).val, (s).val, getprec()) - return u - - def sech(s): - r""" - Hyperbolic secant `\operatorname{sech}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).sech(), dps=25) - 0.6480542736638853995749774 - """ - u = arb.__new__(arb) - arb_sech((u).val, (s).val, getprec()) - return u - - def csch(s): - r""" - Hyperbolic cosecant `\operatorname{csch}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).csch(), dps=25) - 0.8509181282393215451338428 - """ - u = arb.__new__(arb) - arb_csch((u).val, (s).val, getprec()) - return u - - def gamma(s): - r""" - Gamma function `\Gamma(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(10).gamma(), dps=25) - 362880.0000000000000000000 - >>> showgood(lambda: arb(-2.5).gamma(), dps=25) - -0.9453087204829418812256893 - >>> showgood(lambda: (arb.pi() ** 10).gamma(), dps=25) - 1.705646271897306403570389e+424898 - >>> showgood(lambda: arb(0).gamma(), dps=25) # pole - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - """ - u = arb.__new__(arb) - arb_gamma((u).val, (s).val, getprec()) - return u - - @staticmethod - def gamma_fmpq(fmpq s): - r""" - Computes the gamma function `\Gamma(s)` of a given *fmpq* *s*, - exploiting the fact that *s* is an exact rational number to - improve performance. - - >>> from flint import fmpq - >>> from flint import showgood - >>> showgood(lambda: arb.gamma_fmpq(fmpq(1,4)), dps=25) - 3.625609908221908311930685 - """ - u = arb.__new__(arb) - arb_gamma_fmpq((u).val, (s).val, getprec()) - return u - - def rgamma(s): - r""" - Reciprocal gamma function `1/\Gamma(s)`, avoiding - division by zero at the poles of the gamma function. - - >>> from flint import showgood - >>> showgood(lambda: arb(1.5).rgamma(), dps=25) - 1.128379167095512573896159 - >>> print(arb(0).rgamma()) - 0 - >>> print(arb(-1).rgamma()) - 0 - >>> print(arb(-3,1e-10).rgamma()) - [+/- 6.01e-10] - """ - u = arb.__new__(arb) - arb_rgamma((u).val, (s).val, getprec()) - return u - - def lgamma(s): - r""" - Logarithmic gamma function `\log \Gamma(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(100).lgamma(), dps=25) - 359.1342053695753987760440 - - This function is undefined for negative `s`. Use :meth:`.acb.lgamma` - for the complex extension. - """ - u = arb.__new__(arb) - arb_lgamma((u).val, (s).val, getprec()) - return u - - def digamma(s): - r""" - Digamma function `\psi(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).digamma(), dps=25) - -0.5772156649015328606065121 - """ - u = arb.__new__(arb) - arb_digamma((u).val, (s).val, getprec()) - return u - - def rising(s, n): - """ - Rising factorial `(s)_n`. - - >>> from flint import showgood - >>> showgood(lambda: arb.pi().rising(0), dps=25) - 1.000000000000000000000000 - >>> showgood(lambda: arb.pi().rising(10), dps=25) - 299606572.3661012684972888 - >>> showgood(lambda: arb.pi().rising(0.5), dps=25) - 1.703592785410167015590330 - """ - u = arb.__new__(arb) - n = any_as_arb(n) - arb_rising((u).val, (s).val, (n).val, getprec()) - return u - - @staticmethod - def rising_fmpq_ui(fmpq s, ulong n): - """ - Computes the rising factorial `(s)_n` where *s* is a rational - number and *n* is an unsigned integer. The current implementation - does not use the gamma function, so *n* should be moderate. - - >>> from flint import fmpq - >>> from flint import showgood - >>> showgood(lambda: arb.rising_fmpq_ui(fmpq(-1,3), 100), dps=25) - -4.960517984074284420131903e+154 - """ - u = arb.__new__(arb) - arb_rising_fmpq_ui((u).val, (s).val, n, getprec()) - return u - - def rising2(s, ulong n): - """ - Computes the rising factorial `(s)_n` where *n* is an unsigned - integer, along with the first derivative with respect to `(s)_n`. - - The current implementation does not use the gamma function, - so *n* should be moderate. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> u, v = arb(3).rising2(5) - >>> print(u); print(v) - 2520.00000000000 - 2754.00000000000 - """ - u = arb.__new__(arb) - v = arb.__new__(arb) - arb_rising2_ui((u).val, (v).val, (s).val, n, getprec()) - return u, v - - def zeta(s, a=None): - r""" - Riemann zeta function `\zeta(s)` or the Hurwitz - zeta function `\zeta(s,a)` if a second parameter is passed. - - >>> from flint import showgood - >>> showgood(lambda: arb(4.25).zeta(), dps=25) - 1.066954190711214532450370 - >>> showgood(lambda: arb(4.25).zeta(2.75), dps=25) - 0.01991885526414599096374229 - - This function is undefined for some - combinations of `s, a`. Use :meth:`.acb.zeta` for the complex extension. - """ - u = arb.__new__(arb) - if a is None: - arb_zeta((u).val, (s).val, getprec()) - else: - a = any_as_arb(a) - arb_hurwitz_zeta((u).val, (s).val, (a).val, getprec()) - return u - - def agm(s, t=1): - """ - The arithmetic-geometric mean `M(s,t)`, or `M(s) = M(s,1)` - if no extra parameter is passed. - - >>> from flint import showgood - >>> showgood(lambda: arb(2).sqrt().agm(), dps=25) - 1.198140234735592207439922 - >>> showgood(lambda: arb(2).agm(100), dps=25) - 29.64467336236643624632443 - >>> showgood(lambda: arb(0).agm(0), dps=25) - 0 - >>> showgood(arb(0).agm, dps=25) - 0 - >>> showgood(arb(-2).agm, dps=25) # not defined for negatives - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - - This function is undefined for negative input. - Use :meth:`.acb.agm` for the complex extension. - """ - t = any_as_arb(t) - u = arb.__new__(arb) - arb_agm((u).val, (s).val, (t).val, getprec()) - return u - - @staticmethod - def bernoulli(n): - """ - Computes the Bernoulli number `B_n` as an *arb*, - where *n* is a given integer. - - >>> from flint import showgood - >>> showgood(lambda: arb.bernoulli(1), dps=25) - -0.5000000000000000000000000 - >>> showgood(lambda: arb.bernoulli(2), dps=25) - 0.1666666666666666666666667 - >>> showgood(lambda: arb.bernoulli(10**7), dps=25) - -4.983176441416329828329241e+57675260 - >>> showgood(lambda: arb.bernoulli(10**30), dps=25) - -5.048207707665410387507573e+28767525649738633122783863898083 - """ - u = arb.__new__(arb) - n = fmpz(n) - arb_bernoulli_fmpz((u).val, (n).val, getprec()) - return u - - @staticmethod - def bell_number(n): - r""" - Computes the Bell number `B_n` as an *arb*, where *n* is a given integer. - - >>> from flint import showgood - >>> showgood(lambda: arb.bell_number(1), dps=25) - 1.000000000000000000000000 - >>> showgood(lambda: arb.bell_number(10), dps=25) - 115975.0000000000000000000 - >>> showgood(lambda: arb.bell_number(10**20), dps=25) - 5.382701131762816107395343e+1794956117137290721328 - """ - u = arb.__new__(arb) - n = fmpz(n) - arb_bell_fmpz((u).val, (n).val, getprec()) - return u - - @staticmethod - def partitions_p(n): - """ - Number of partitions of the integer *n*, evaluated as an *arb*. - - >>> from flint import showgood - >>> showgood(lambda: arb.partitions_p(10), dps=25) - 42.00000000000000000000000 - >>> showgood(lambda: arb.partitions_p(100), dps=25) - 190569292.0000000000000000 - >>> showgood(lambda: arb.partitions_p(10**50), dps=25) - 3.285979358867807890529967e+11140086280105007830283557 - """ - u = arb.__new__(arb) - n = fmpz(n) - arb_partitions_fmpz((u).val, (n).val, getprec()) - return u - - def bernoulli_poly(s, ulong n): - """ - Returns the value of the Bernoulli polynomial `B_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb("3.141").bernoulli_poly(5), dps=25) - 113.5165117028492010000000 - """ - u = arb.__new__(arb) - arb_bernoulli_poly_ui((u).val, n, s.val, getprec()) - return u - - def fac(s): - r""" - Factorial, equivalent to `s! = \Gamma(s+1)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).fac(), dps=25) - 120.0000000000000000000000 - >>> showgood(lambda: arb("0.1").fac(), dps=25) - 0.9513507698668731836292487 - """ - u = arb.__new__(arb) - arb_add_ui((u).val, s.val, 1, getprec()) - arb_gamma((u).val, (u).val, getprec()) - return u - - @staticmethod - def fac_ui(ulong n): - """ - Factorial `n!`, given an integer. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> print(arb.fac_ui(10)) - 3628800.00000000 - >>> from flint import showgood - >>> showgood(lambda: arb.fac_ui(10**9).log(), dps=25) - 19723265848.22698260792313 - """ - u = arb.__new__(arb) - arb_fac_ui((u).val, n, getprec()) - return u - - def bin(s, ulong k): - r""" - Binomial coefficient `{s \choose k}`. Currently *k* is limited - to an integer; this restriction will be removed in the future - by using the gamma function. - - >>> from flint import arb, ctx, showgood - >>> ctx.prec = 53 - >>> print(arb(10).bin(5)) - 252.000000000000 - >>> showgood(lambda: arb.pi().bin(100), dps=25) - 5.478392395095119521549286e-9 - """ - u = arb.__new__(arb) - arb_bin_ui((u).val, (s).val, k, getprec()) - return u - - @staticmethod - def bin_uiui(ulong n, ulong k): - r""" - Binomial coefficient `{n \choose k}`. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> print(arb.bin_uiui(10, 5)) - 252.000000000000 - """ - u = arb.__new__(arb) - arb_bin_uiui((u).val, n, k, getprec()) - return u - - @staticmethod - def fib(n): - """ - Computes the Fibonacci number `F_n` as an *arb*, - where *n* is a given integer. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> print(arb.fib(10)) - 55.0000000000000 - >>> from flint import showgood - >>> showgood(lambda: arb.fib(10**100).log(), dps=25) - 4.812118250596034474977589e+99 - """ - u = arb.__new__(arb) - n = fmpz(n) - arb_fib_fmpz((u).val, (n).val, getprec()) - return u - - def polylog(self, s): - r""" - Polylogarithm `\operatorname{Li}_s(z)` where - the argument *z* is given by *self* and the order *s* is given - as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: arb(-1).polylog(2), dps=25) - -0.8224670334241132182362076 - >>> showgood(lambda: arb(-3).polylog(1.75), dps=25) - -1.813689945878060161612620 - >>> showgood(lambda: arb(-2.5).polylog(4.75), dps=25) - -2.322090601785704585092044 - - This function is undefined for some - combinations of `s, z`. Use :meth:`.acb.polylog` for the complex extension. - """ - u = arb.__new__(arb) - s = any_as_arb(s) - arb_polylog((u).val, (s).val, (self).val, getprec()) - return u - - def airy_ai(s, int derivative=0): - r""" - Airy function `\operatorname{Ai}(s)`, or - `\operatorname{Ai}'(s)` if *derivative* is 1. - - >>> from flint import showgood - >>> showgood(lambda: arb(-1).airy_ai(), dps=25) - 0.5355608832923521187995166 - >>> showgood(lambda: arb(-1).airy_ai(derivative=1), dps=25) - -0.01016056711664520939504547 - """ - u = arb.__new__(arb) - if derivative == 0: - arb_hypgeom_airy((u).val, NULL, NULL, NULL, (s).val, getprec()) - elif derivative == 1: - arb_hypgeom_airy(NULL, (u).val, NULL, NULL, (s).val, getprec()) - else: - raise ValueError("derivative must be 0 or 1") - return u - - def airy_bi(s, int derivative=0): - r""" - Airy function `\operatorname{Bi}(s)`, or - `\operatorname{Bi}'(s)` if *derivative* is 1. - - >>> from flint import showgood - >>> showgood(lambda: arb(-1).airy_bi(), dps=25) - 0.1039973894969446118886900 - >>> showgood(lambda: arb(-1).airy_bi(derivative=1), dps=25) - 0.5923756264227923508167792 - """ - u = arb.__new__(arb) - if derivative == 0: - arb_hypgeom_airy(NULL, NULL, (u).val, NULL, (s).val, getprec()) - elif derivative == 1: - arb_hypgeom_airy(NULL, NULL, NULL, (u).val, (s).val, getprec()) - else: - raise ValueError("derivative must be 0 or 1") - return u - - def airy(s): - r""" - Computes the Airy function values `\operatorname{Ai}(s)`, - `\operatorname{Ai}'(s)`, `\operatorname{Bi}(s)`, - `\operatorname{Bi}'(s)` simultaneously, returning a tuple. - - >>> from flint import showgood - >>> showgood(lambda: arb(-1).airy(), dps=10) - (0.5355608833, -0.01016056712, 0.1039973895, 0.5923756264) - """ - u = arb.__new__(arb) - v = arb.__new__(arb) - w = arb.__new__(arb) - z = arb.__new__(arb) - arb_hypgeom_airy((u).val, (v).val, - (w).val, (z).val, (s).val, getprec()) - return u, v, w, z - - @staticmethod - def airy_ai_zero(n, int derivative=0): - r""" - For positive integer *n*, returns the zero `a_n` of the - Airy function `\operatorname{Ai}(s)`, or the corresponding - zero `a'_n` of `\operatorname{Ai}'(s)` if *derivative* is 1. - - >>> from flint import showgood - >>> showgood(lambda: arb.airy_ai_zero(1), dps=25) - -2.338107410459767038489197 - >>> showgood(lambda: arb.airy_ai_zero(1000), dps=25) - -281.0315196125215528353364 - >>> showgood(lambda: arb.airy_ai_zero(1, derivative=1), dps=25) - -1.018792971647471089017325 - """ - n = fmpz(n) - if n <= 0: - raise ValueError("index must be >= 1") - u = arb.__new__(arb) - if derivative == 0: - arb_hypgeom_airy_zero((u).val, NULL, NULL, NULL, (n).val, getprec()) - elif derivative == 1: - arb_hypgeom_airy_zero(NULL, (u).val, NULL, NULL, (n).val, getprec()) - else: - raise ValueError("derivative must be 0 or 1") - return u - - @staticmethod - def airy_bi_zero(n, int derivative=0): - r""" - For positive integer *n*, returns the zero `b_n` of the - Airy function `\operatorname{Bi}(s)`, or the corresponding - zero `b'_n` of `\operatorname{Bi}'(s)` if *derivative* is 1. - - >>> from flint import showgood - >>> showgood(lambda: arb.airy_bi_zero(1), dps=25) - -1.173713222709127924919980 - >>> showgood(lambda: arb.airy_bi_zero(1000), dps=25) - -280.9378112034152401578834 - >>> showgood(lambda: arb.airy_bi_zero(1, derivative=1), dps=25) - -2.294439682614123246622459 - """ - n = fmpz(n) - if n <= 0: - raise ValueError("index must be >= 1") - u = arb.__new__(arb) - if derivative == 0: - arb_hypgeom_airy_zero(NULL, NULL, (u).val, NULL, (n).val, getprec()) - elif derivative == 1: - arb_hypgeom_airy_zero(NULL, NULL, NULL, (u).val, (n).val, getprec()) - else: - raise ValueError("derivative must be 0 or 1") - return u - - def chebyshev_t(s, n): - r""" - Chebyshev function of the first kind `T_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).chebyshev_t(3), dps=25) - -0.8518518518518518518518519 - """ - v = arb.__new__(arb) - n = any_as_arb(n) - arb_hypgeom_chebyshev_t((v).val, (n).val, (s).val, getprec()) - return v - - def chebyshev_u(s, n): - r""" - Chebyshev function of the second kind `U_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).chebyshev_u(3), dps=25) - -1.037037037037037037037037 - """ - v = arb.__new__(arb) - n = any_as_arb(n) - arb_hypgeom_chebyshev_u((v).val, (n).val, (s).val, getprec()) - return v - - def jacobi_p(s, n, a, b): - r""" - Jacobi polynomial (or Jacobi function) `P_n^{a,b}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).jacobi_p(5, 0.25, 0.5), dps=25) - 0.4131944444444444444444444 - """ - v = arb.__new__(arb) - n = any_as_arb(n) - a = any_as_arb(a) - b = any_as_arb(b) - arb_hypgeom_jacobi_p((v).val, (n).val, (a).val, (b).val, (s).val, getprec()) - return v - - def gegenbauer_c(s, n, m): - r""" - Gegenbauer function `C_n^{m}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).gegenbauer_c(5, 0.25), dps=25) - 0.1321855709876543209876543 - """ - v = arb.__new__(arb) - n = any_as_arb(n) - m = any_as_arb(m) - arb_hypgeom_gegenbauer_c((v).val, (n).val, (m).val, (s).val, getprec()) - return v - - def laguerre_l(s, n, m=0): - r""" - Laguerre function `L_n^{m}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).laguerre_l(5, 0.25), dps=25) - 0.03871323490012002743484225 - """ - v = arb.__new__(arb) - n = any_as_arb(n) - m = any_as_arb(m) - arb_hypgeom_laguerre_l((v).val, (n).val, (m).val, (s).val, getprec()) - return v - - def hermite_h(s, n): - r""" - Hermite function `H_n(s)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).hermite_h(5), dps=25) - 34.20576131687242798353909 - """ - v = arb.__new__(arb) - n = any_as_arb(n) - arb_hypgeom_hermite_h((v).val, (n).val, (s).val, getprec()) - return v - - def legendre_p(s, n, m=0, int type=2): - r""" - Legendre function of the first kind `P_n^m(z)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).legendre_p(5), dps=25) - 0.3333333333333333333333333 - >>> showgood(lambda: (arb(1)/3).legendre_p(5, 1.5), dps=25) - -2.372124991643971726805456 - >>> showgood(lambda: (arb(3)).legendre_p(5, 1.5, type=3), dps=25) - 17099.70021476473458984981 - - The optional parameter *type* can be 2 or 3, and selects between - two different branch cut conventions (see *Mathematica* and *mpmath*). - """ - v = arb.__new__(arb) - n = any_as_arb(n) - m = any_as_arb(m) - if type != 2 and type != 3: - raise ValueError("type must be 2 or 3") - type -= 2 - arb_hypgeom_legendre_p((v).val, (n).val, (m).val, (s).val, type, getprec()) - return v - - def legendre_q(s, n, m=0, int type=2): - r""" - Legendre function of the second kind `Q_n^m(z)`. - - >>> from flint import showgood - >>> showgood(lambda: (arb(1)/3).legendre_q(5), dps=25) - 0.1655245300933242182362054 - >>> showgood(lambda: (arb(1)/3).legendre_q(5, 1.5), dps=25) - -6.059967350218583975575616 - - The optional parameter *type* can be 2 or 3, and selects between - two different branch cut conventions (see *Mathematica* and *mpmath*). - """ - v = arb.__new__(arb) - n = any_as_arb(n) - m = any_as_arb(m) - if type != 2 and type != 3: - raise ValueError("type must be 2 or 3") - type -= 2 - arb_hypgeom_legendre_q((v).val, (n).val, (m).val, (s).val, type, getprec()) - return v - - @staticmethod - def legendre_p_root(ulong n, ulong k, bint weight=False): - r""" - Returns the index-*k* zero of the Legendre polynomial `P_n(x)`. - The zeros are indexed in decreasing order. - - If *weight* is True, returns a tuple (*x*, *w*) where *x* is - the zero and *w* is the corresponding weight for Gauss-Legendre - quadrature on `(-1,1)`. - - >>> from flint import showgood - >>> for k in range(5): - ... showgood(lambda: arb.legendre_p_root(5,k), dps=25) - ... - 0.9061798459386639927976269 - 0.5384693101056830910363144 - 0 - -0.5384693101056830910363144 - -0.9061798459386639927976269 - - >>> for k in range(3): - ... showgood(lambda: arb.legendre_p_root(3,k,weight=True), dps=15) - ... - (0.774596669241483, 0.555555555555556) - (0, 0.888888888888889) - (-0.774596669241483, 0.555555555555556) - - """ - cdef arb x, w - if k >= n: - raise ValueError("require k < n") - if weight: - x = arb.__new__(arb) - w = arb.__new__(arb) - arb_hypgeom_legendre_p_ui_root(x.val, w.val, n, k, getprec()) - return x, w - else: - x = arb.__new__(arb) - arb_hypgeom_legendre_p_ui_root(x.val, NULL, n, k, getprec()) - return x - - def erf(s): - r""" - Error function `\operatorname{erf}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).erf(), dps=25) - 0.9999779095030014145586272 - """ - u = arb.__new__(arb) - arb_hypgeom_erf((u).val, (s).val, getprec()) - return u - - def erfc(s): - r""" - Complementary error function `\operatorname{erfc}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).erfc(), dps=25) - 2.209049699858544137277613e-5 - """ - u = arb.__new__(arb) - arb_hypgeom_erfc((u).val, (s).val, getprec()) - return u - - def erfinv(s): - r""" - Inverse error function `\operatorname{erfinv}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(.25).erfinv(), dps=25) - 0.2253120550121781047250140 - """ - u = arb.__new__(arb) - arb_hypgeom_erfinv((u).val, (s).val, getprec()) - return u - - def erfcinv(s): - r""" - Inverse complementary error function `\operatorname{erfcinv}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(.25).erfcinv(), dps=25) - 0.8134198475976185416902894 - """ - u = arb.__new__(arb) - arb_hypgeom_erfcinv((u).val, (s).val, getprec()) - return u - - def erfi(s): - r""" - Imaginary error function `\operatorname{erfi}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).erfi(), dps=25) - 1629.994622601565651061648 - """ - u = arb.__new__(arb) - arb_hypgeom_erfi((u).val, (s).val, getprec()) - return u - - def fresnel_s(s, bint normalized=True): - r""" - Fresnel sine integral `S(s)`, optionally not normalized. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).fresnel_s(), dps=25) - 0.4963129989673750360976123 - >>> showgood(lambda: arb(3).fresnel_s(normalized=False), dps=25) - 0.7735625268937690171497722 - """ - u = arb.__new__(arb) - arb_hypgeom_fresnel((u).val, NULL, (s).val, normalized, getprec()) - return u - - def fresnel_c(s, bint normalized=True): - r""" - Fresnel cosine integral `C(s)`, optionally not normalized. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).fresnel_c(), dps=25) - 0.6057207892976856295561611 - >>> showgood(lambda: arb(3).fresnel_c(normalized=False), dps=25) - 0.7028635577302687301744099 - """ - u = arb.__new__(arb) - arb_hypgeom_fresnel(NULL, (u).val, (s).val, normalized, getprec()) - return u - - def ei(s): - r""" - Exponential integral `\operatorname{Ei}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).ei(), dps=25) - 9.933832570625416558008336 - """ - u = arb.__new__(arb) - arb_hypgeom_ei((u).val, (s).val, getprec()) - return u - - def si(s): - r""" - Sine integral `\operatorname{Si}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).si(), dps=25) - 1.848652527999468256397730 - """ - u = arb.__new__(arb) - arb_hypgeom_si((u).val, (s).val, getprec()) - return u - - def ci(s): - r""" - Cosine integral `\operatorname{Ci}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).ci(), dps=25) - 0.1196297860080003276264723 - """ - u = arb.__new__(arb) - arb_hypgeom_ci((u).val, (s).val, getprec()) - return u - - def shi(s): - r""" - Hyperbolic sine integral `\operatorname{Shi}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).shi(), dps=25) - 4.973440475859806797710418 - """ - u = arb.__new__(arb) - arb_hypgeom_shi((u).val, (s).val, getprec()) - return u - - def chi(s): - r""" - Hyperbolic cosine integral `\operatorname{Chi}(s)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(3).chi(), dps=25) - 4.960392094765609760297918 - """ - u = arb.__new__(arb) - arb_hypgeom_chi((u).val, (s).val, getprec()) - return u - - def li(s, bint offset=False): - r""" - Logarithmic integral `\operatorname{li}(s)`, optionally - the offset logarithmic integral - `\operatorname{Li}(s) = \operatorname{li}(s) - \operatorname{li}(2)`. - - >>> from flint import showgood - >>> showgood(lambda: arb(10).li(), dps=25) - 6.165599504787297937522982 - >>> showgood(lambda: arb(10).li(offset=True), dps=25) - 5.120435724669805152678393 - """ - u = arb.__new__(arb) - arb_hypgeom_li((u).val, (s).val, offset, getprec()) - return u - - def bessel_j(self, n): - r""" - Bessel function `J_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).bessel_j(1), dps=25) - -0.3275791375914652220377343 - """ - n = any_as_arb(n) - u = arb.__new__(arb) - arb_hypgeom_bessel_j((u).val, (n).val, (self).val, getprec()) - return u - - def bessel_y(self, n): - r""" - Bessel function `Y_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).bessel_y(1), dps=25) - 0.1478631433912268448010507 - """ - n = any_as_arb(n) - u = arb.__new__(arb) - arb_hypgeom_bessel_y((u).val, (n).val, (self).val, getprec()) - return u - - def bessel_k(self, n, bint scaled=False): - r""" - Bessel function `K_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - Optionally a scaled Bessel function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).bessel_k(1), dps=25) - 0.004044613445452164208365022 - >>> showgood(lambda: arb(5).bessel_k(1, scaled=True), dps=25) - 0.6002738587883125829360457 - """ - n = any_as_arb(n) - u = arb.__new__(arb) - if scaled: - arb_hypgeom_bessel_k_scaled((u).val, (n).val, (self).val, getprec()) - else: - arb_hypgeom_bessel_k((u).val, (n).val, (self).val, getprec()) - return u - - def bessel_i(self, n, bint scaled=False): - r""" - Bessel function `I_n(z)`, where the argument *z* is given by - *self* and the order *n* is passed as an extra parameter. - Optionally a scaled Bessel function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).bessel_i(1), dps=25) - 24.33564214245052719914305 - >>> showgood(lambda: arb(5).bessel_i(1, scaled=True), dps=25) - 0.1639722669445423569261229 - """ - n = any_as_arb(n) - u = arb.__new__(arb) - if scaled: - arb_hypgeom_bessel_i_scaled((u).val, (n).val, (self).val, getprec()) - else: - arb_hypgeom_bessel_i((u).val, (n).val, (self).val, getprec()) - return u - - def gamma_upper(self, s, int regularized=0): - r""" - Upper incomplete gamma function `\Gamma(s,z)`. The argument *z* - is given by *self* and the order *s* is passed as an extra parameter. - Optionally the regularized version `Q(s,z)` can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).gamma_upper(2.5), dps=25) - 0.1000132513171574223384170 - >>> showgood(lambda: arb(5).gamma_upper(2.5, regularized=1), dps=25) - 0.07523524614651217872207687 - """ - s = any_as_arb(s) - u = arb.__new__(arb) - arb_hypgeom_gamma_upper((u).val, (s).val, (self).val, regularized, getprec()) - return u - - def gamma_lower(self, s, int regularized=0): - r""" - Lower incomplete gamma function `\gamma(s,z)`. The argument *z* - is given by *self* and the order *s* is passed as an extra parameter. - Optionally the regularized versions `P(s,z)` and - `\gamma^{*}(s,z) = z^{-s} P(s,z)` can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).gamma_lower(2.5), dps=25) - 1.229327136861979598135209 - >>> showgood(lambda: arb(5).gamma_lower(2.5, regularized=1), dps=25) - 0.9247647538534878212779231 - >>> showgood(lambda: arb(5).gamma_lower(2.5, regularized=2), dps=25) - 0.01654269482249807489997922 - """ - s = any_as_arb(s) - u = arb.__new__(arb) - arb_hypgeom_gamma_lower((u).val, (s).val, (self).val, regularized, getprec()) - return u - - def beta_lower(self, a, b, int regularized=0): - r""" - Lower incomplete beta function `B(a,b;z)`. The argument *z* - is given by *self* and the parameters *a* and *b* are passed - as extra function arguments. - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb("0.9").beta_lower(1, 2.5), dps=25) - 0.3987350889359326482672004 - >>> showgood(lambda: arb("0.9").beta_lower(1, 2.5, regularized=True), dps=25) - 0.9968377223398316206680011 - """ - a = any_as_arb(a) - b = any_as_arb(b) - u = arb.__new__(arb) - arb_hypgeom_beta_lower((u).val, (a).val, (b).val, (self).val, regularized, getprec()) - return u - - def expint(self, s): - r""" - Generalized exponential integral `E_s(z)`. The argument *z* - is given by *self* and the order *s* is passed as an extra parameter. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).expint(2), dps=25) - 0.0009964690427088381099832386 - """ - s = any_as_arb(s) - u = arb.__new__(arb) - arb_hypgeom_expint((u).val, (s).val, (self).val, getprec()) - return u - - def hypgeom(self, a, b, bint regularized=False): - r""" - Generalized hypergeometric function `{}_pF_q(a;b;z)`. - The argument *z* is given by *self* and *a* and *b* - are additional lists of complex numbers defining the parameters. - Optionally the regularized hypergeometric function can be - computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(5).hypgeom([1,2,3],[5,4.5,6]), dps=25) - 1.301849229178968153998454 - >>> showgood(lambda: arb(5).hypgeom([1,2,3],[5,4.5,6],regularized=True), dps=25) - 3.886189282817193519132054e-5 - """ - cdef long i, p, q - cdef arb_ptr aa, bb - a = [any_as_arb(t) for t in a] - b = [any_as_arb(t) for t in b] - p = len(a) - q = len(b) - aa = libc.stdlib.malloc(p * cython.sizeof(arb_struct)) - bb = libc.stdlib.malloc(q * cython.sizeof(arb_struct)) - for i in range(p): - aa[i] = ((a[i])).val[0] - for i in range(q): - bb[i] = ((b[i])).val[0] - u = arb.__new__(arb) - arb_hypgeom_pfq((u).val, aa, p, bb, q, (self).val, regularized, getprec()) - libc.stdlib.free(aa) - libc.stdlib.free(bb) - return u - - def hypgeom_u(self, a, b): - r""" - The hypergeometric function `U(a,b,z)` where the argument *z* - is given by *self* - - >>> from flint import showgood - >>> showgood(lambda: arb(5).hypgeom_u(1, 2.5), dps=25) - 0.2184157028890778783289036 - """ - a = any_as_arb(a) - b = any_as_arb(b) - u = arb.__new__(arb) - arb_hypgeom_u((u).val, (a).val, (b).val, (self).val, getprec()) - return u - - def hypgeom_1f1(self, a, b, bint regularized=False): - r""" - The hypergeometric function `{}_1F_1(a,b,z)` where the argument *z* - is given by *self* - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(-5).hypgeom_1f1(1, 2.5), dps=25) - 0.2652884733179767675077230 - >>> showgood(lambda: arb(-5).hypgeom_1f1(1, 2.5, regularized=True), dps=25) - 0.1995639910417191573048664 - """ - a = any_as_arb(a) - b = any_as_arb(b) - u = arb.__new__(arb) - arb_hypgeom_1f1((u).val, (a).val, (b).val, (self).val, regularized, getprec()) - return u - - def hypgeom_0f1(self, a, bint regularized=False): - r""" - The hypergeometric function `{}_0F_1(a,z)` where the argument *z* - is given by *self* - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(-5).hypgeom_0f1(2.5), dps=25) - 0.003114611044402738470826907 - >>> showgood(lambda: arb(-5).hypgeom_0f1(2.5, regularized=True), dps=25) - 0.002342974810739764377177885 - """ - a = any_as_arb(a) - u = arb.__new__(arb) - arb_hypgeom_0f1((u).val, (a).val, (self).val, regularized, getprec()) - return u - - def hypgeom_2f1(self, a, b, c, bint regularized=False, bint ab=False, bint ac=False, bc=False, abc=False): - r""" - The hypergeometric function `{}_2F_1(a,b,c,z)` where the argument *z* - is given by *self* - Optionally the regularized version of this function can be computed. - - >>> from flint import showgood - >>> showgood(lambda: arb(-5).hypgeom_2f1(1,2,3), dps=25) - 0.2566592424617555999350018 - >>> showgood(lambda: arb(-5).hypgeom_2f1(1,2,3,regularized=True), dps=25) - 0.1283296212308777999675009 - - The flags *ab*, *ac*, *bc*, *abc* can be used to specify whether the - parameter differences `a-b`, `a-c`, `b-c` and `a+b-c` represent - exact integers, even if the input intervals are inexact. - If the parameters are exact, these flags are not needed. - - >>> from flint import showgood - >>> showgood(lambda: arb("9/10").hypgeom_2f1(arb(2).sqrt(), 0.5, arb(2).sqrt()+1.5, abc=True), dps=25) - 1.447530478120770807945697 - >>> showgood(lambda: arb("9/10").hypgeom_2f1(arb(2).sqrt(), 0.5, arb(2).sqrt()+1.5), dps=25) # doctest: +SKIP - Traceback (most recent call last): - ... - ValueError: no convergence (maxprec=960, try higher maxprec) - """ - cdef int flags - a = any_as_arb(a) - b = any_as_arb(b) - c = any_as_arb(c) - u = arb.__new__(arb) - flags = 0 - if regularized: - flags |= 1 - if ab: - flags |= 2 - if ac: - flags |= 4 - if bc: - flags |= 8 - if abc: - flags |= 16 - arb_hypgeom_2f1((u).val, (a).val, (b).val, (c).val, - (self).val, flags, getprec()) - return u - - @staticmethod - def pi(): - r""" - Returns the constant `\pi` as an *arb*. - - >>> from flint import showgood - >>> showgood(arb.pi, dps=25) - 3.141592653589793238462643 - """ - u = arb.__new__(arb) - arb_const_pi((u).val, getprec()) - return u - - @staticmethod - def const_sqrt_pi(): - r""" - The constant `\sqrt{\pi}`. - - >>> from flint import showgood - >>> showgood(arb.const_sqrt_pi, dps=25) - 1.772453850905516027298167 - """ - u = arb.__new__(arb) - arb_const_sqrt_pi((u).val, getprec()) - return u - - @staticmethod - def const_log2(): - r""" - The constant `\log(2)`. - - >>> from flint import showgood - >>> showgood(arb.const_log2, dps=25) - 0.6931471805599453094172321 - """ - u = arb.__new__(arb) - arb_const_log2((u).val, getprec()) - return u - - @staticmethod - def const_log10(): - r""" - The constant `\log(10)`. - - >>> from flint import showgood - >>> showgood(arb.const_log10, dps=25) - 2.302585092994045684017991 - """ - u = arb.__new__(arb) - arb_const_log10((u).val, getprec()) - return u - - @staticmethod - def const_euler(): - r""" - Euler's constant `\gamma`. - - >>> from flint import showgood - >>> showgood(arb.const_euler, dps=25) - 0.5772156649015328606065121 - """ - u = arb.__new__(arb) - arb_const_euler((u).val, getprec()) - return u - - @staticmethod - def const_catalan(): - """ - Catalan's constant. - - >>> from flint import showgood - >>> showgood(arb.const_catalan, dps=25) - 0.9159655941772190150546035 - """ - u = arb.__new__(arb) - arb_const_catalan((u).val, getprec()) - return u - - @staticmethod - def const_e(): - """ - The constant `e`. - - >>> from flint import showgood - >>> showgood(arb.const_e, dps=25) - 2.718281828459045235360287 - """ - u = arb.__new__(arb) - arb_const_e((u).val, getprec()) - return u - - @staticmethod - def const_khinchin(): - """ - Khinchin's constant `K`. - - >>> from flint import showgood - >>> showgood(arb.const_khinchin, dps=25) - 2.685452001065306445309715 - """ - u = arb.__new__(arb) - arb_const_khinchin((u).val, getprec()) - return u - - @staticmethod - def const_glaisher(): - """ - Glaisher's constant. - - >>> from flint import showgood - >>> showgood(arb.const_glaisher, dps=25) - 1.282427129100622636875343 - """ - u = arb.__new__(arb) - arb_const_glaisher((u).val, getprec()) - return u - - @staticmethod - def pos_inf(): - u = arb.__new__(arb) - arb_pos_inf((u).val) - return u - - @staticmethod - def neg_inf(): - u = arb.__new__(arb) - arb_neg_inf((u).val) - return u - - @staticmethod - def nan(): - u = arb.__new__(arb) - arb_indeterminate((u).val) - return u - - def unique_fmpz(self): - r""" - If *self* represents exactly one integer, returns this value - as an *fmpz*; otherwise returns *None*. - - >>> arb("5 +/- 0.1").unique_fmpz() - 5 - >>> arb("5 +/- 0.9").unique_fmpz() - 5 - >>> arb("5.1 +/- 0.9").unique_fmpz() - >>> - - """ - u = fmpz.__new__(fmpz) - if arb_get_unique_fmpz((u).val, self.val): - return u - else: - return None - - def rel_accuracy_bits(self): - return arb_rel_accuracy_bits(self.val) - - def rel_one_accuracy_bits(self): - return arb_rel_one_accuracy_bits(self.val) - - def bits(self): - r""" - Returns number of bits needed to represent absolute value of mantissa of the midpoint; returns 0 if midpoint is special value. - - >>> arb("2047/2048").bits() - 11 - """ - return arb_bits(self.val) - - def lambertw(s, int branch=0): - r""" - Lambert *W* function, `W_k(s)`. Either the principal - branch (`k = 0`) or the `k = -1` branch can be computed - by specifying *branch*. - - >>> from flint import showgood - >>> showgood(lambda: arb(10).lambertw(), dps=25) - 1.745528002740699383074301 - >>> showgood(lambda: arb("-0.1").lambertw(-1), dps=25) - -3.577152063957297218409392 - """ - cdef int flags - if branch == 0: - flags = 0 - elif branch == -1: - flags = 1 - else: - raise ValueError("invalid branch") - u = arb.__new__(arb) - arb_lambertw((u).val, (s).val, flags, getprec()) - return u - - def nonnegative_part(self): - res = arb.__new__(arb) - arb_set_round((res).val, (self).val, getprec()) - arb_nonnegative_part((res).val, (res).val) - return res - - def union(s, t): - """ - Returns a ball containing the union of *s* and *t*. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> x = arb(3).union(5); x.lower(); x.upper() - [2.99999999813735 +/- 4.86e-15] - [5.00000000186265 +/- 4.86e-15] - """ - v = arb.__new__(arb) - t = any_as_arb(t) - arb_union((v).val, (s).val, (t).val, getprec()) - return v - - def intersection(s, t): - """ - Returns a ball containing the intersection of *s* and *t*. - If *s* and *t* are non-overlapping, raises ValueError. - - >>> arb("10 +/- 8.001").intersection(arb("0 +/- 2.001")) - [2.00 +/- 1.01e-3] - >>> arb(2).intersection(3) - Traceback (most recent call last): - ... - ValueError: empty intersection - """ - v = arb.__new__(arb) - t = any_as_arb(t) - if arb_intersection((v).val, (s).val, (t).val, getprec()): - return v - raise ValueError("empty intersection") - - def min(s, t): - """ - Minimum value of *s* and *t*. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> arb(2).min(3) - 2.00000000000000 - >>> arb(2).min(arb("3 +/- 1.1")) - [2e+0 +/- 0.101] - """ - v = arb.__new__(arb) - t = any_as_arb(t) - arb_min((v).val, (s).val, (t).val, getprec()) - return v - - def max(s, t): - """ - Maximum value of *s* and *t*. - - >>> arb(2).max(arb("3 +/- 1.1")) - [+/- 4.11] - >>> arb(4).max(arb("3 +/- 1.1")) - [4e+0 +/- 0.101] - """ - v = arb.__new__(arb) - t = any_as_arb(t) - arb_max((v).val, (s).val, (t).val, getprec()) - return v - - def root(s, ulong n): - """ - Principal *n*-th root of *s*. - - >>> from flint import showgood - >>> showgood(lambda: arb(10).root(3), dps=25) - 2.154434690031883721759294 - """ - v = arb.__new__(arb) - arb_root_ui((v).val, (s).val, n, getprec()) - return v - - @staticmethod - def gram_point(n): - """ - Returns the *n*-th Gram point. - - >>> from flint import showgood - >>> showgood(lambda: arb.gram_point(-1), dps=25) - 9.666908056130192141261536 - >>> showgood(lambda: arb.gram_point(0), dps=25) - 17.84559954041086081682634 - >>> showgood(lambda: arb.gram_point(10**30), dps=25) - 9.829776286927442475869051e+28 - """ - n = fmpz(n) - v = arb.__new__(arb) - acb_dirichlet_gram_point((v).val, (n).val, NULL, NULL, getprec()) - return v - - def zeta_nzeros(x): - """ - Number of zeros of the Riemann zeta function with positive - imaginary part between 0 and *x*. - - >>> from flint import arb, ctx - >>> ctx.prec = 53 - >>> arb("-5").zeta_nzeros() - 0 - >>> arb("14").zeta_nzeros() - 0 - >>> arb("15").zeta_nzeros() - 1.00000000000000 - >>> arb("14.1 +/- 0.1").zeta_nzeros() - [+/- 1.01] - >>> arb("100").zeta_nzeros() - 29.0000000000000 - >>> arb("1e6").zeta_nzeros() - 1747146.00000000 - - """ - v = arb.__new__(arb) - acb_dirichlet_zeta_nzeros((v).val, (x).val, getprec()) - return v - - def backlund_s(x): - """ - Backlund *S* function related to the Riemann zeta function. - - >>> from flint import showgood - >>> showgood(lambda: arb(123).backlund_s(), dps=25) - 0.4757920863536796196115749 - """ - v = arb.__new__(arb) - acb_dirichlet_backlund_s((v).val, (x).val, getprec()) - return v - - def coulomb(self, l, eta): - r""" - Computes the Coulomb wave functions `F_{\ell}(\eta,z)`, - `G_{\ell}(\eta,z)`, where *z* is given by *self*. - Both function values are computed simultaneously and a tuple - is returned. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).coulomb(0.5, 0.25), dps=10) - (0.4283180781, 1.218454487) - """ - l = any_as_arb(l) - eta = any_as_arb(eta) - F = arb.__new__(arb) - G = arb.__new__(arb) - arb_hypgeom_coulomb((F).val, (G).val, - (l).val, (eta).val, (self).val, getprec()) - return F, G - - def coulomb_f(self, l, eta): - r""" - Regular Coulomb wave function `F_{\ell}(\eta,z)` where - *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).coulomb_f(0.5, 0.25), dps=25) - 0.4283180781043541845555944 - """ - l = any_as_arb(l) - eta = any_as_arb(eta) - F = arb.__new__(arb) - arb_hypgeom_coulomb((F).val, NULL, - (l).val, (eta).val, (self).val, getprec()) - return F - - def coulomb_g(self, l, eta): - r""" - Irregular Coulomb wave function `G_{\ell}(\eta,z)` where - *z* is given by *self*. - - >>> from flint import showgood - >>> showgood(lambda: arb(1).coulomb_g(0.5, 0.25), dps=25) - 1.218454487206367973745641 - """ - l = any_as_arb(l) - eta = any_as_arb(eta) - G = arb.__new__(arb) - arb_hypgeom_coulomb(NULL, (G).val, - (l).val, (eta).val, (self).val, getprec()) - return G diff --git a/src/flint/types/arb_mat.pxd b/src/flint/types/arb_mat.pxd deleted file mode 100644 index 1da1fcd7..00000000 --- a/src/flint/types/arb_mat.pxd +++ /dev/null @@ -1,7 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat -from flint.flintlib.functions.arb_mat cimport arb_mat_t - -cdef class arb_mat(flint_mat): - cdef arb_mat_t val - cpdef long nrows(self) - cpdef long ncols(self) diff --git a/src/flint/types/arb_mat.pyx b/src/flint/types/arb_mat.pyx deleted file mode 100644 index ed8f13ab..00000000 --- a/src/flint/types/arb_mat.pyx +++ /dev/null @@ -1,717 +0,0 @@ -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_base cimport flint_mat -from flint.types.fmpq_mat cimport fmpq_mat -from flint.types.fmpz_mat cimport fmpz_mat -from flint.types.arb cimport arb -from flint.types.arb_poly cimport arb_poly -from flint.types.arb cimport any_as_arb -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq -from flint.types.acb cimport acb -from flint.types.acb_mat cimport acb_mat -from flint.types.acb cimport any_as_acb - -from flint.flintlib.functions.fmpz_mat cimport fmpz_mat_nrows, fmpz_mat_ncols -from flint.flintlib.functions.fmpq_mat cimport fmpq_mat_nrows, fmpq_mat_ncols -from flint.flintlib.functions.arf cimport * -from flint.flintlib.functions.arb cimport * -from flint.flintlib.types.arb cimport ( - arb_radref, - arb_midref, - arb_mat_nrows, - arb_mat_ncols, - arb_mat_entry, -) -from flint.flintlib.functions.arb_mat cimport * -cimport cython - -cdef arb_mat_coerce_operands(x, y): - if isinstance(y, (fmpz_mat, fmpq_mat)): - return x, arb_mat(y) - if isinstance(y, (int, float, fmpz, fmpq, arb)): - return x, arb_mat(x.nrows(), x.ncols(), y) - if isinstance(y, (complex, acb)): - return acb_mat(x), acb_mat(x.nrows(), x.ncols(), y) - return NotImplemented, NotImplemented - -cdef arb_mat_coerce_scalar(x, y): - if isinstance(y, (int, float, fmpz, fmpq, arb)): - return x, any_as_arb(y) - if isinstance(y, (complex, acb)): - return acb_mat(x), any_as_acb(y) - return NotImplemented, NotImplemented - -cdef class arb_mat(flint_mat): - """ - Represents a matrix over the real numbers. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> A = arb_mat([[1,2],[3,4]]) ** 2 / 5 - >>> A - [[1.40000000000000 +/- 3.12e-16], 2.00000000000000] - [ 3.00000000000000, [4.40000000000000 +/- 1.43e-15]] - >>> print(A.str(5, radius=False)) - [1.4000, 2.0000] - [3.0000, 4.4000] - - """ - - # cdef arb_mat_t val - - def __cinit__(self): - arb_mat_init(self.val, 0, 0) - - def __dealloc__(self): - arb_mat_clear(self.val) - - @classmethod - def convert_operand(cls, x): - """ - Attempts to convert *x* to an *arb_mat*, returning NotImplemented - if unsuccessful. - """ - if typecheck(x, cls): - return x - if typecheck(x, fmpz_mat) or typecheck(x, fmpq_mat): - return cls(x) - return NotImplemented - - @classmethod - def convert(cls, x): - """ - Attempts to convert *x* to an *arb_mat*, raising TypeError if - unsuccessful. - """ - x = cls.convert_operand(x) - if x is NotImplemented: - raise TypeError("unable to convert type %s to type %s" % (type(x), cls)) - return x - - @cython.embedsignature(False) - def __init__(self, *args): - cdef long m, n, i, j - if len(args) == 1: - val = args[0] - if typecheck(val, arb_mat): - m = arb_mat_nrows((val).val) - n = arb_mat_ncols((val).val) - arb_mat_init(self.val, m, n) - arb_mat_set(self.val, (val).val) - elif typecheck(val, fmpz_mat): - m = fmpz_mat_nrows((val).val) - n = fmpz_mat_ncols((val).val) - arb_mat_init(self.val, m, n) - arb_mat_set_fmpz_mat(self.val, (val).val) - elif typecheck(val, fmpq_mat): - m = fmpq_mat_nrows((val).val) - n = fmpq_mat_ncols((val).val) - arb_mat_init(self.val, m, n) - arb_mat_set_fmpq_mat(self.val, (val).val, getprec()) - elif isinstance(val, (list, tuple)): - m = len(val) - n = 0 - if m != 0: - if not isinstance(val[0], (list, tuple)): - raise TypeError("single input to arb_mat must be a list of lists") - n = len(val[0]) - for i from 1 <= i < m: - if len(val[i]) != n: - raise ValueError("input rows have different lengths") - arb_mat_init(self.val, m, n) - for i from 0 <= i < m: - row = val[i] - for j from 0 <= j < n: - x = arb(row[j]) - arb_set(arb_mat_entry(self.val, i, j), (x).val) - elif hasattr(val, "rows"): # allows conversion from mpmath matrices - m = val.rows - n = val.cols - arb_mat_init(self.val, m, n) - for i from 0 <= i < m: - for j from 0 <= j < n: - x = arb(val[i, j]) - arb_set(arb_mat_entry(self.val, i, j), (x).val) - else: - raise TypeError("cannot create arb_mat from input of type %s" % type(val)) - elif len(args) == 2: - m, n = args - arb_mat_init(self.val, m, n) - elif len(args) == 3: - m, n, entries = args - arb_mat_init(self.val, m, n) - if isinstance(entries, (int, float, fmpz, fmpq, arb)): - c = entries - entries = [0] * (m * n) - for i in range(min(m, n)): - entries[i*n + i] = c - else: - entries = list(entries) - if len(entries) != m*n: - raise ValueError("list of entries has the wrong length") - for i from 0 <= i < m: - for j from 0 <= j < n: - x = arb(entries[i*n + j]) - arb_set(arb_mat_entry(self.val, i, j), (x).val) - else: - raise ValueError("arb_mat: expected 1-3 arguments") - - def __bool__(self): - raise NotImplementedError - - cpdef long nrows(s): - """ - Returns the number of rows of *s*. - """ - return arb_mat_nrows(s.val) - - cpdef long ncols(s): - """ - Returns the number of columns of *s*. - """ - return arb_mat_ncols(s.val) - - def __getitem__(self, index): - cdef long i, j - cdef arb x - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise ValueError("index %i,%i exceeds matrix dimensions" % (i, j)) - x = arb.__new__(arb) - arb_set(x.val, arb_mat_entry(self.val, i, j)) - return x - - def __setitem__(self, index, value): - cdef long i, j - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise ValueError("index %i,%i exceeds matrix dimensions" % (i, j)) - c = any_as_arb(value) - arb_set(arb_mat_entry(self.val, i, j), (c).val) - - def transpose(s): - """ - Returns the transpose of *s*. - """ - cdef arb_mat u - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_ncols(s.val), arb_mat_nrows(s.val)) - arb_mat_transpose(u.val, s.val) - return u - - def det(s): - """ - Returns the determinant of the square matrix *s* as an *arb*. - - >>> from flint import showgood, ctx - >>> ctx.prec = 53 - >>> A = arb_mat(3, 3, range(9)) - >>> showgood(lambda: A.det(), dps=25) # exact singular - 0 - >>> A[2,2] = 10 - >>> showgood(lambda: A.det(), dps=25) - -6.000000000000000000000000 - >>> showgood(lambda: (A * A).det()) - 36.0000000000000 - >>> print(arb_mat(0, 0).det()) - 1.00000000000000 - """ - cdef arb d - if arb_mat_nrows(s.val) != arb_mat_ncols(s.val): - raise ValueError("matrix must be square") - d = arb.__new__(arb) - arb_mat_det(d.val, s.val, getprec()) - return d - - def __pos__(s): - cdef arb_mat u - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - arb_mat_set(u.val, s.val) # round? - return u - - def __neg__(s): - cdef arb_mat u - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - arb_mat_neg(u.val, s.val) # round? - return u - - def __add__(s, t): - cdef long m, n - if not isinstance(t, arb_mat): - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - - m = (s).nrows() - n = (s).ncols() - if m != (t).nrows() or n != (t).ncols(): - raise ValueError("incompatible shapes for matrix addition") - u = arb_mat.__new__(arb_mat) - arb_mat_init((u).val, m, n) - arb_mat_add((u).val, (s).val, (t).val, getprec()) - return u - - def __radd__(s, t): - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - cdef long m, n - if not isinstance(t, arb_mat): - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - - m = (s).nrows() - n = (s).ncols() - if m != (t).nrows() or n != (t).ncols(): - raise ValueError("incompatible shapes for matrix addition") - u = arb_mat.__new__(arb_mat) - arb_mat_init((u).val, m, n) - arb_mat_sub((u).val, (s).val, (t).val, getprec()) - return u - - def __rsub__(s, t): - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def _scalar_mul_(s, arb t): - cdef arb_mat u - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - arb_mat_scalar_mul_arb(u.val, s.val, t.val, getprec()) - return u - - def __mul__(s, t): - cdef arb_mat u - if not isinstance(t, arb_mat): - c, d = arb_mat_coerce_scalar(s, t) - if c is not NotImplemented: - return c._scalar_mul_(d) - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - - if arb_mat_ncols((s).val) != arb_mat_nrows((t).val): - raise ValueError("incompatible shapes for matrix multiplication") - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows((s).val), arb_mat_ncols((t).val)) - arb_mat_mul(u.val, (s).val, (t).val, getprec()) - return u - - def __rmul__(s, t): - c, d = arb_mat_coerce_scalar(s, t) - if c is not NotImplemented: - return c._scalar_mul_(d) - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - def _scalar_div_(s, arb t): - cdef arb_mat u - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - arb_mat_scalar_div_arb(u.val, s.val, t.val, getprec()) - return u - - def __truediv__(s, t): - s, t = arb_mat_coerce_scalar(s, t) - if s is NotImplemented: - return s - return s._scalar_div_(t) - - def __pow__(s, e, m): - cdef arb_mat u - cdef ulong exp - cdef long n - exp = e - n = arb_mat_nrows((s).val) - if n != arb_mat_ncols((s).val): - raise ValueError("matrix must be square") - if m is not None: - raise NotImplementedError("modular matrix exponentiation") - u = arb_mat.__new__(arb_mat) - arb_mat_init((u).val, n, n) - arb_mat_pow_ui((u).val, (s).val, exp, getprec()) - return u - - def inv(s, bint nonstop=False): - """ - Returns the inverse matrix of the square matrix *s*. - - If *s* is numerically singular, raises :exc:`ZeroDivisionError` - unless *nonstop* is set in which case a matrix with NaN entries - is returned. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> A = arb_mat(2, 2, [1, 5, 2, 4]) - >>> print(A * A.inv()) - [[1.00000000000000 +/- 6.11e-16], [+/- 3.34e-16]] - [ [+/- 4.45e-16], [1.00000000000000 +/- 5.56e-16]] - >>> A = arb_mat(2, 2, [1, 5, 2, 10]) - >>> A.inv() - Traceback (most recent call last): - ... - ZeroDivisionError: matrix is singular - >>> A.inv(nonstop=True) - [nan, nan] - [nan, nan] - - """ - cdef arb_mat u - if arb_mat_nrows(s.val) != arb_mat_ncols(s.val): - raise ValueError("matrix must be square") - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - if not arb_mat_inv(u.val, s.val, getprec()): - if nonstop: - for i from 0 <= i < arb_mat_nrows(u.val): - for j from 0 <= j < arb_mat_nrows(u.val): - arb_indeterminate(arb_mat_entry(u.val, i, j)) - else: - raise ZeroDivisionError("matrix is singular") - return u - - def solve(s, t, bint nonstop=False, algorithm=None): - """ - Solves `AX = B` where *A* is a square matrix given by *s* and - `B` is a matrix given by *t*. - - If *A* is numerically singular, raises :exc:`ZeroDivisionError` - unless *nonstop* is set in which case a matrix with NaN entries - is returned. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> A = arb_mat(2, 2, [1, 2, 3, 4]) - >>> X = arb_mat(2, 3, range(6)) - >>> B = A * X - >>> print(A.solve(B)) - [ [+/- 4.74e-15], [1.00000000000000 +/- 4.78e-15], [2.00000000000000 +/- 8.52e-15]] - [[3.00000000000000 +/- 3.56e-15], [4.00000000000000 +/- 3.59e-15], [5.00000000000000 +/- 6.28e-15]] - >>> arb_mat([[1,1],[0,0]]).solve(arb_mat(2,3)) - Traceback (most recent call last): - ... - ZeroDivisionError: singular matrix in solve() - >>> arb_mat([[1,1],[0,0]]).solve(arb_mat(2,3), nonstop=True) - [nan, nan, nan] - [nan, nan, nan] - - The optional *algorithm* can be None (default), "lu", or "precond". - It can also be set to "approx" in which case an approximate - floating-point solution (warning: without error bounds!) is returned. - """ - cdef arb_mat u - cdef bint res - cdef long i, j - t = arb_mat.convert(t) - if (arb_mat_nrows(s.val) != arb_mat_ncols(s.val) or - arb_mat_nrows(s.val) != arb_mat_nrows((t).val)): - raise ValueError("need a square system and compatible right hand side") - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows((t).val), arb_mat_ncols((t).val)) - if algorithm is None: - res = arb_mat_solve(u.val, s.val, (t).val, getprec()) - elif algorithm == 'lu': - res = arb_mat_solve_lu(u.val, s.val, (t).val, getprec()) - elif algorithm == 'precond': - res = arb_mat_solve_precond(u.val, s.val, (t).val, getprec()) - elif algorithm == "approx": - res = arb_mat_approx_solve(u.val, s.val, (t).val, getprec()) - else: - raise ValueError("unknown algorithm") - if not res: - if nonstop: - for i from 0 <= i < arb_mat_nrows(u.val): - for j from 0 <= j < arb_mat_ncols(u.val): - arb_indeterminate(arb_mat_entry(u.val, i, j)) - else: - raise ZeroDivisionError("singular matrix in solve()") - return u - - def exp(s): - """ - Returns the matrix exponential of *s*. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> print(arb_mat(2, 2, [1, 4, -2, 1]).exp()) - [ [-2.58607310345045 +/- 5.06e-15], [1.18429895089106 +/- 1.15e-15]] - [[-0.592149475445530 +/- 5.73e-16], [-2.58607310345045 +/- 5.06e-15]] - """ - cdef arb_mat u - if arb_mat_nrows(s.val) != arb_mat_ncols(s.val): - raise ValueError("matrix must be square") - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - arb_mat_exp(u.val, s.val, getprec()) - return u - - def charpoly(s): - """ - Returns the characteristic polynomial of *s* as an *arb_poly*. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> print(arb_mat(2, 2, [1, 1, 1, 0]).charpoly()) - 1.00000000000000*x^2 + (-1.00000000000000)*x + (-1.00000000000000) - """ - cdef arb_poly u - if arb_mat_nrows(s.val) != arb_mat_ncols(s.val): - raise ValueError("matrix must be square") - u = arb_poly.__new__(arb_poly) - arb_mat_charpoly(u.val, s.val, getprec()) - return u - - def mid(s): - """ - Returns the matrix consisting of the midpoints of the entries of *s*. - - >>> arb_mat([["1.5 +/- 0.1", 3]]).mid() - [1.50000000000000, 3.00000000000000] - """ - cdef arb_mat u - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, arb_mat_nrows(s.val), arb_mat_ncols(s.val)) - arb_mat_get_mid(u.val, s.val) - return u - - def trace(s): - """ - Returns the trace of the square matrix *s* as an *arb*. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> arb_mat([[3,4],[5,7]]).trace() - 10.0000000000000 - """ - cdef arb d - if arb_mat_nrows(s.val) != arb_mat_ncols(s.val): - raise ValueError("matrix must be square") - d = arb.__new__(arb) - arb_mat_trace(d.val, s.val, getprec()) - return d - - @classmethod - def hilbert(cls, long n, long m): - """ - Returns the *n* by *m* truncated Hilbert matrix. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> arb_mat.hilbert(6,2) - [ 1.00000000000000, 0.500000000000000] - [ 0.500000000000000, [0.333333333333333 +/- 3.71e-16]] - [[0.333333333333333 +/- 3.71e-16], 0.250000000000000] - [ 0.250000000000000, [0.200000000000000 +/- 4.45e-17]] - [[0.200000000000000 +/- 4.45e-17], [0.166666666666667 +/- 3.71e-16]] - [[0.166666666666667 +/- 3.71e-16], [0.142857142857143 +/- 1.79e-16]] - """ - cdef arb_mat u - assert n >= 0 - assert m >= 0 - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, n, m) - arb_mat_hilbert(u.val, getprec()) - return u - - @classmethod - def pascal(cls, long n, long m, int triangular=0): - """ - Returns the *n* by *m* truncated Pascal matrix. If *triangular* - is 0, the symmetric version of this matrix is returned; if - *triangular* is -1 or 1, the lower or upper triangular version - of the Pascal matrix is returned. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> arb_mat.pascal(3, 4) - [1.00000000000000, 1.00000000000000, 1.00000000000000, 1.00000000000000] - [1.00000000000000, 2.00000000000000, 3.00000000000000, 4.00000000000000] - [1.00000000000000, 3.00000000000000, 6.00000000000000, 10.0000000000000] - >>> arb_mat.pascal(3, 4, 1) - [1.00000000000000, 1.00000000000000, 1.00000000000000, 1.00000000000000] - [ 0, 1.00000000000000, 2.00000000000000, 3.00000000000000] - [ 0, 0, 1.00000000000000, 3.00000000000000] - >>> arb_mat.pascal(3, 4, -1) - [1.00000000000000, 0, 0, 0] - [1.00000000000000, 1.00000000000000, 0, 0] - [1.00000000000000, 2.00000000000000, 1.00000000000000, 0] - - """ - cdef arb_mat u - assert n >= 0 - assert m >= 0 - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, n, m) - arb_mat_pascal(u.val, triangular, getprec()) - return u - - @classmethod - def stirling(cls, long n, long m, int kind=0): - """ - Returns the *n* by *m* truncated Stirling matrix. The - parameter *kind* can be 0 for unsigned Stirling numbers of the - first kind, 1 for signed Stirling numbers of the first kind, - and 2 for Stirling numbers of the second kind. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> arb_mat.stirling(5, 4) - [1.00000000000000, 0, 0, 0] - [ 0, 1.00000000000000, 0, 0] - [ 0, 1.00000000000000, 1.00000000000000, 0] - [ 0, 2.00000000000000, 3.00000000000000, 1.00000000000000] - [ 0, 6.00000000000000, 11.0000000000000, 6.00000000000000] - >>> arb_mat.stirling(5, 4, 1) - [1.00000000000000, 0, 0, 0] - [ 0, 1.00000000000000, 0, 0] - [ 0, -1.00000000000000, 1.00000000000000, 0] - [ 0, 2.00000000000000, -3.00000000000000, 1.00000000000000] - [ 0, -6.00000000000000, 11.0000000000000, -6.00000000000000] - >>> arb_mat.stirling(5, 4, 2) - [1.00000000000000, 0, 0, 0] - [ 0, 1.00000000000000, 0, 0] - [ 0, 1.00000000000000, 1.00000000000000, 0] - [ 0, 1.00000000000000, 3.00000000000000, 1.00000000000000] - [ 0, 1.00000000000000, 7.00000000000000, 6.00000000000000] - """ - cdef arb_mat u - assert n >= 0 - assert m >= 0 - if not 0 <= kind <= 2: - raise ValueError("expected kind = 0, 1 or 2") - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, n, m) - arb_mat_stirling(u.val, kind, getprec()) - return u - - @classmethod - def dct(cls, long n, long m=-1): - """ - Returns the size *n* by *n* DCT matrix (optionally a separate - number of columns *m* can be given in which case the periodic - extension of the smaller dimension is used). - - >>> print(arb_mat.dct(4).str(4)) - [ 0.5000, 0.5000, 0.5000, 0.5000] - [[0.6533 +/- 1.86e-5], [0.2706 +/- 1.96e-6], [-0.2706 +/- 1.96e-6], [-0.6533 +/- 1.86e-5]] - [ [0.5000 +/- 3e-9], [-0.5000 +/- 3e-9], [-0.5000 +/- 3e-9], [0.5000 +/- 3e-9]] - [[0.2706 +/- 1.96e-6], [-0.6533 +/- 1.86e-5], [0.6533 +/- 1.86e-5], [-0.2706 +/- 1.96e-6]] - - """ - cdef arb_mat u - if m < 0: - m = n - assert n >= 0 - u = arb_mat.__new__(arb_mat) - arb_mat_init(u.val, n, m) - arb_mat_dct(u.val, 0, getprec()) - return u - - def overlaps(s, arb_mat t): - """ - Returns whether *s* and *t* overlap (in the sense of balls). - - >>> A = arb_mat([[1,2],[3,4]]) - >>> ((A / 3) * 3).overlaps(A) - True - >>> ((A / 3) * 3 + 0.0001).overlaps(A) - False - """ - return bool(arb_mat_overlaps(s.val, t.val)) - - def contains(s, t): - """ - Returns whether *t* is contained in *s* (in the sense of balls). - - >>> from flint import fmpz_mat - >>> from flint import fmpq_mat - >>> A = arb_mat([[1,2],[3,4]]) - >>> ((A / 3) * 3).contains(A) - True - >>> A.contains((A / 3) * 3) - False - >>> ((A / 3) * 3).contains(fmpz_mat([[1,2],[3,4]])) - True - >>> ((A / 3) * 3).contains(fmpz_mat([[1,2],[3,5]])) - False - >>> (A / 3).contains(fmpq_mat([[1,2],[3,4]]) / 3) - True - """ - if isinstance(t, arb_mat): - return bool(arb_mat_contains(s.val, (t).val)) - if isinstance(t, fmpz_mat): - return bool(arb_mat_contains_fmpz_mat(s.val, (t).val)) - if isinstance(t, fmpq_mat): - return bool(arb_mat_contains_fmpq_mat(s.val, (t).val)) - raise TypeError("expected a matrix of compatible type") - - def chop(s, tol): - """ - Returns a copy of *s* where entries that are bounded by *tol* in - magnitude have been replaced by exact zeros. - - >>> from flint import arb_mat, ctx - >>> ctx.prec = 53 - >>> print(arb_mat.stirling(4, 4).inv().str(5, radius=False)) - [1.0000, 0, 0, 0] - [ 0, 1.0000, 0e-14, 0e-15] - [ 0, -1.0000, 1.0000, 0e-15] - [ 0, 1.0000, -3.0000, 1.0000] - >>> print(arb_mat.stirling(4, 4).inv().chop(1e-6).str(5, radius=False)) - [1.0000, 0, 0, 0] - [ 0, 1.0000, 0, 0] - [ 0, -1.0000, 1.0000, 0] - [ 0, 1.0000, -3.0000, 1.0000] - - """ - cdef arb_mat u - cdef arb b - cdef long i, j, n, m - u = arb_mat(s) - n = s.nrows() - m = s.ncols() - b = arb(tol) - arb_get_mag_lower(arb_radref(b.val), b.val) - arf_zero(arb_midref(b.val)) - for i from 0 <= i < n: - for j from 0 <= j < m: - # and arb_contains_zero(...)? - if arb_contains(b.val, arb_mat_entry(u.val, i, j)): - arb_zero(arb_mat_entry(u.val, i, j)) - return u - - def __richcmp__(s, t, int op): - cdef bint res - if not (op == 2 or op == 3): - raise ValueError("comparing matrices") - if type(s) is not type(t): - s, t = arb_mat_coerce_operands(s, t) - if s is NotImplemented: - return s - if op == 2: - res = arb_mat_eq((s).val, (t).val) - else: - res = arb_mat_ne((s).val, (t).val) - return res - - def eig(s, *args, **kwargs): - r""" - Computes eigenvalues and/or eigenvectors of this matrix. - This is just a wrapper for :meth:`.acb_mat.eig`; see the - documentation for that method for details. - """ - return acb_mat(s).eig(*args, **kwargs) diff --git a/src/flint/types/arb_poly.pxd b/src/flint/types/arb_poly.pxd deleted file mode 100644 index b1790aeb..00000000 --- a/src/flint/types/arb_poly.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_poly -from flint.flintlib.functions.arb_poly cimport arb_poly_t - -cdef arb_poly_set_list(arb_poly_t poly, list val, long prec) - -cdef class arb_poly(flint_poly): - cdef arb_poly_t val - cpdef long length(self) - cpdef long degree(self) diff --git a/src/flint/types/arb_poly.pyx b/src/flint/types/arb_poly.pyx deleted file mode 100644 index f00889ff..00000000 --- a/src/flint/types/arb_poly.pyx +++ /dev/null @@ -1,436 +0,0 @@ -from cpython.list cimport PyList_Size as PyList_GET_SIZE -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_base cimport flint_poly -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.arb cimport arb_set_python -from flint.types.arb cimport any_as_arb -from flint.types.arb cimport arb -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq -from flint.types.acb cimport acb -from flint.types.acb_poly cimport acb_poly - -from flint.flintlib.types.arb cimport arb_struct, arb_poly_set_arb -from flint.flintlib.functions.arb cimport * -from flint.flintlib.functions.arb_poly cimport * -cimport libc.stdlib - -cdef arb_poly_coerce_operands(x, y): - if isinstance(y, (int, float, fmpz, fmpq, arb, fmpz_poly, fmpq_poly)): - return x, arb_poly(y) - if isinstance(y, (complex, acb)): - return acb_poly(x), acb_poly(y) - return NotImplemented, NotImplemented - -cdef arb_poly_set_list(arb_poly_t poly, list val, long prec): - cdef long i, n - cdef arb_t x - n = PyList_GET_SIZE(val) - arb_poly_fit_length(poly, n) - arb_init(x) - for i in range(n): - if typecheck(val[i], arb): - arb_poly_set_coeff_arb(poly, i, ((val[i])).val) - elif arb_set_python(x, val[i], 1): - arb_poly_set_coeff_arb(poly, i, x) - else: - arb_clear(x) - raise TypeError("unsupported coefficient type for arb_poly") - arb_clear(x) - -cdef class arb_poly(flint_poly): - - # cdef arb_poly_t val - - def __cinit__(self): - arb_poly_init(self.val) - - def __dealloc__(self): - arb_poly_clear(self.val) - - def __init__(self, val=None): - if val is not None: - if typecheck(val, arb_poly): - arb_poly_set(self.val, (val).val) - elif typecheck(val, fmpz_poly): - arb_poly_set_fmpz_poly(self.val, (val).val, getprec()) - elif typecheck(val, fmpq_poly): - arb_poly_set_fmpq_poly(self.val, (val).val, getprec()) - elif typecheck(val, list): - arb_poly_set_list(self.val, val, getprec()) - else: - val = any_as_arb(val) - arb_poly_set_arb(self.val, (val).val) - - def __len__(self): - return arb_poly_length(self.val) - - cpdef long length(self): - return arb_poly_length(self.val) - - cpdef long degree(self): - return arb_poly_degree(self.val) - - def __getitem__(self, long i): - cdef arb x - x = arb() - if i >= 0: - arb_poly_get_coeff_arb(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if not typecheck(x, arb): - x = arb(x) - arb_poly_set_coeff_arb(self.val, i, (x).val) - - def repr(self): - return "arb_poly([%s])" % (", ".join(map(str, self))) - - @classmethod - def from_roots(cls, roots): - """ - Constructs the monic polynomial whose roots are the given real numbers. - - >>> from flint import arb_poly, ctx - >>> ctx.prec = 53 - >>> arb_poly.from_roots(range(4)) - 1.00000000000000*x^4 + (-6.00000000000000)*x^3 + 11.0000000000000*x^2 + (-6.00000000000000)*x - - There is currently no dedicated method to construct a real polynomial - from complex conjugate roots (use :meth:`.acb_poly.from_roots`). - """ - cdef arb_ptr xs - cdef long i, n - roots = [any_as_arb(x) for x in roots] - n = len(roots) - xs = libc.stdlib.malloc(sizeof(arb_struct) * n) - for i in range(n): - xs[i] = ((roots[i])).val[0] - u = arb_poly.__new__(arb_poly) - arb_poly_product_roots((u).val, xs, n, getprec()) - libc.stdlib.free(xs) - return u - - def complex_roots(self, **kwargs): - """ - Compute the complex roots of the polynomial by converting - from arb_poly to acb_poly - """ - return acb_poly(self).roots(**kwargs) - - def evaluate(self, xs, algorithm='fast'): - """ - Multipoint evaluation: evaluates *self* at the list of - points *xs*. The algorithm can be 'iter' or 'fast'. The 'fast' - algorithm is asymptotically fast, but has worse numerical stability. - - Note: for ordinary single-point evaluation, just call the polynomial - with the point as the argument. - """ - cdef arb_ptr xsv, ysv - cdef long i, n - assert algorithm in ('fast', 'iter') - xs = [any_as_arb(x) for x in xs] - n = len(xs) - if n == 0: - return [] - ys = [arb.__new__(arb) for i in range(n)] - xsv = libc.stdlib.malloc(sizeof(arb_struct) * n) - ysv = libc.stdlib.malloc(sizeof(arb_struct) * n) - for i in range(n): - xsv[i] = ((xs[i])).val[0] - ysv[i] = ((ys[i])).val[0] - if algorithm == 'fast': - arb_poly_evaluate_vec_fast(ysv, (self).val, xsv, n, getprec()) - else: - arb_poly_evaluate_vec_iter(ysv, (self).val, xsv, n, getprec()) - for i in range(n): # move values - ((ys[i])).val[0] = ysv[i] - libc.stdlib.free(xsv) - libc.stdlib.free(ysv) - return ys - - @classmethod - def interpolate(cls, xs, ys, algorithm='fast'): - """ - Constructs the unique interpolating polynomial of length at most *n* - taking the values *ys* when evaluated at the *n* distinct points *xs*. - Algorithm can be 'newton', 'barycentric' or 'fast'. The 'fast' - algorithm is asymptotically fast, but has worse numerical stability. - """ - cdef arb_ptr xsv, ysv - cdef long i, n - assert algorithm in ('fast', 'newton', 'barycentric') - xs = [any_as_arb(x) for x in xs] - ys = [any_as_arb(y) for y in ys] - n = len(xs) - if len(ys) != n: - raise ValueError("xs and ys must have the same length") - xsv = libc.stdlib.malloc(sizeof(arb_struct) * n) - ysv = libc.stdlib.malloc(sizeof(arb_struct) * n) - for i in range(n): - xsv[i] = ((xs[i])).val[0] - ysv[i] = ((ys[i])).val[0] - u = arb_poly.__new__(arb_poly) - if algorithm == 'fast': - arb_poly_interpolate_fast((u).val, xsv, ysv, n, getprec()) - elif algorithm == 'newton': - arb_poly_interpolate_newton((u).val, xsv, ysv, n, getprec()) - else: - arb_poly_interpolate_barycentric((u).val, xsv, ysv, n, getprec()) - libc.stdlib.free(xsv) - libc.stdlib.free(ysv) - return u - - def derivative(self): - u = arb_poly.__new__(arb_poly) - arb_poly_derivative((u).val, (self).val, getprec()) - return u - - def integral(self): - u = arb_poly.__new__(arb_poly) - arb_poly_integral((u).val, (self).val, getprec()) - return u - - def __pos__(self): - return self # ? - - def __neg__(s): - u = arb_poly.__new__(arb_poly) - arb_poly_neg((u).val, (s).val) - return u - - def __add__(s, t): - if not isinstance(t, arb_poly): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - u = arb_poly.__new__(arb_poly) - arb_poly_add((u).val, (s).val, (t).val, getprec()) - return u - - def __radd__(s, t): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - if not isinstance(t, arb_poly): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - u = arb_poly.__new__(arb_poly) - arb_poly_sub((u).val, (s).val, (t).val, getprec()) - return u - - def __rsub__(s, t): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def __mul__(s, t): - if not isinstance(t, arb_poly): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - u = arb_poly.__new__(arb_poly) - arb_poly_mul((u).val, (s).val, (t).val, getprec()) - return u - - def __rmul__(s, t): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - def __floordiv__(s, t): - if not isinstance(t, arb_poly): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s // t - q = arb_poly.__new__(arb_poly) - r = arb_poly.__new__(arb_poly) - if arb_poly_divrem((q).val, (r).val, - (s).val, (t).val, getprec()): - return q - else: - raise ZeroDivisionError("arb_poly leading coefficient must be nonzero") - - def __rfloordiv__(s, t): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t // s - - def __mod__(s, t): - if not isinstance(t, arb_poly): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return s % t - q = arb_poly.__new__(arb_poly) - r = arb_poly.__new__(arb_poly) - if arb_poly_divrem((q).val, (r).val, - (s).val, (t).val, getprec()): - return r - else: - raise ZeroDivisionError("arb_poly leading coefficient must be nonzero") - - def __rmod__(s, t): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return t % s - - def __divmod__(s, t): - if not isinstance(t, arb_poly): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return divmod(s, t) - q = arb_poly.__new__(arb_poly) - r = arb_poly.__new__(arb_poly) - if arb_poly_divrem((q).val, (r).val, - (s).val, (t).val, getprec()): - return q, r - else: - raise ZeroDivisionError("arb_poly leading coefficient must be nonzero") - - def __rdivmod__(s, t): - s, t = arb_poly_coerce_operands(s, t) - if s is NotImplemented: - return s - return divmod(t, s) - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then a copy of ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> f = arb_poly([1,2,3]) - >>> f.truncate(3) - 3.00000000000000*x^2 + 2.00000000000000*x + 1.00000000000000 - >>> f.truncate(2) - 2.00000000000000*x + 1.00000000000000 - >>> f.truncate(1) - 1.00000000000000 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - - """ - cdef arb_poly res - res = arb_poly.__new__(arb_poly) - - length = arb_poly_length(self.val) - if n <= 0: # return zero - return res - elif n > length: # do nothing - arb_poly_set(res.val, self.val) - else: - arb_poly_set_trunc(res.val, self.val, n) - - return res - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> f = arb_poly([1,2,3]) - >>> f.left_shift(0) - 3.00000000000000*x^2 + 2.00000000000000*x + 1.00000000000000 - >>> f.left_shift(1) - 3.00000000000000*x^3 + 2.00000000000000*x^2 + 1.00000000000000*x - >>> f.left_shift(4) - 3.00000000000000*x^6 + 2.00000000000000*x^5 + 1.00000000000000*x^4 - - """ - cdef arb_poly res - res = arb_poly.__new__(arb_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - arb_poly_shift_left(res.val, self.val, n) - else: # do nothing, just copy self - arb_poly_set(res.val, self.val) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> f = arb_poly([1,2,3]) - >>> f.right_shift(0) - 3.00000000000000*x^2 + 2.00000000000000*x + 1.00000000000000 - >>> f.right_shift(1) - 3.00000000000000*x + 2.00000000000000 - >>> f.right_shift(4) - 0 - """ - cdef arb_poly res - res = arb_poly.__new__(arb_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - arb_poly_shift_right(res.val, self.val, n) - else: # do nothing, just copy self - arb_poly_set(res.val, self.val) - - return res - - def __pow__(arb_poly s, ulong exp, mod): - if mod is not None: - raise NotImplementedError("arb_poly modular exponentiation") - u = arb_poly.__new__(arb_poly) - arb_poly_pow_ui((u).val, (s).val, exp, getprec()) - return u - - def __call__(s, t): - if typecheck(t, arb_poly): - u = arb_poly.__new__(arb_poly) - arb_poly_compose((u).val, (s).val, (t).val, getprec()) - return u - if typecheck(t, arb): - u = arb.__new__(arb) - arb_poly_evaluate((u).val, (s).val, (t).val, getprec()) - return u - if typecheck(t, acb): - u = acb.__new__(acb) - arb_poly_evaluate_acb((u).val, (s).val, (t).val, getprec()) - return u - if isinstance(t, (int, float, fmpz, fmpq)): - return s(arb(t)) - if isinstance(t, (fmpz_poly, fmpq_poly)): - return s(arb_poly(t)) - if isinstance(t, (complex)): - return s(acb(t)) - raise TypeError("cannot call arb_poly with input of type %s", type(t)) - - def unique_fmpz_poly(self): - u = fmpz_poly.__new__(fmpz_poly) - if arb_poly_get_unique_fmpz_poly((u).val, self.val): - return u - else: - return None diff --git a/src/flint/types/arb_series.pxd b/src/flint/types/arb_series.pxd deleted file mode 100644 index c7bc04ab..00000000 --- a/src/flint/types/arb_series.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series - -from flint.flintlib.functions.arb_poly cimport arb_poly_t - -cdef class arb_series(flint_series): - cdef arb_poly_t val - cdef long _prec - cpdef long length(self) - cpdef valuation(self) diff --git a/src/flint/types/arb_series.pyx b/src/flint/types/arb_series.pyx deleted file mode 100644 index 016070c5..00000000 --- a/src/flint/types/arb_series.pyx +++ /dev/null @@ -1,872 +0,0 @@ -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getprec, getcap -from flint.flint_base.flint_context cimport thectx -from flint.flint_base.flint_base cimport flint_series -from flint.types.fmpz_series cimport fmpz_series -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq_series cimport fmpq_series -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.arb_poly cimport arb_poly_set_list -from flint.types.arb cimport arb -from flint.types.arb_poly cimport arb_poly -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq -from flint.types.acb cimport acb -from flint.types.acb_poly cimport acb_poly -from flint.types.acb_series cimport acb_series - -from flint.flintlib.functions.arb cimport * -from flint.flintlib.functions.arb_poly cimport * -from flint.flintlib.functions.arb_hypgeom cimport * - -ctx = thectx - -cdef arb_series_coerce_operands(x, y): - if isinstance(y, (int, float, fmpz, fmpz_poly, fmpz_series, fmpq, fmpq_poly, fmpq_series, arb, arb_poly)): - return x, arb_series(y) - if isinstance(y, (complex, acb, acb_poly, acb_series)): - return acb_series(x), acb_series(y) - return NotImplemented, NotImplemented - -cdef class arb_series(flint_series): - - # cdef arb_poly_t val - # cdef long _prec - - def __cinit__(self): - arb_poly_init(self.val) - self._prec = 0 - - def __dealloc__(self): - arb_poly_clear(self.val) - - def __init__(self, val=None, prec=None): - if prec is None: - self._prec = getcap() - else: - self._prec = prec - if self._prec < 0: - self._prec = -1 - if val is not None: - if typecheck(val, arb_series): - arb_poly_set(self.val, (val).val) - self._prec = min((val)._prec, getcap()) - elif typecheck(val, fmpz_series): - arb_poly_set_fmpz_poly(self.val, (val).val, getprec()) - self._prec = min((val)._prec, getcap()) - elif typecheck(val, fmpz_poly): - arb_poly_set_fmpz_poly(self.val, (val).val, getprec()) - elif typecheck(val, arb_poly): - arb_poly_set(self.val, (val).val) - elif typecheck(val, list): - arb_poly_set_list(self.val, val, getprec()) - else: - arb_poly_set_list(self.val, [val], getprec()) - arb_poly_truncate(self.val, max(0, self._prec)) - - @property - def prec(self): - """ - The term precision of the finitely approximated series. - - >>> from flint import arb_series, ctx - >>> ctx.cap = 10 - >>> s = arb_series([1,2]) - >>> s - 1.00000000000000 + 2.00000000000000*x + O(x^10) - >>> s.prec - 10 - >>> s2 = arb_series([1,2], prec=3) - >>> s2 - 1.00000000000000 + 2.00000000000000*x + O(x^3) - >>> s2.prec - 3 - """ - return self._prec - - def __len__(self): - return arb_poly_length(self.val) - - cpdef long length(self): - return arb_poly_length(self.val) - - def __getitem__(self, long i): - cdef arb x - x = arb() - if i < 0: - return x - arb_poly_get_coeff_arb(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if not typecheck(x, arb): - x = arb(x) - arb_poly_set_coeff_arb(self.val, i, (x).val) - - def repr(self, **kwargs): - return "arb_series([%s], prec=%s)" % (", ".join(map(str, self)), self._prec) - - def str(self, *args, **kwargs): - if self._prec > 0: - s = arb_poly(list(self)).str(ascending=True, *args, **kwargs) - return s + (" + O(x^%s)" % self._prec) - elif self._prec == 0: - return "O(x^0)" - else: - return "(invalid power series)" - - def __pos__(self): - return self - - def __neg__(s): - cdef long cap - u = arb_series.__new__(arb_series) - cap = getcap() - cap = min(cap, (s)._prec) - if cap > 0: - arb_poly_neg((u).val, (s).val) - arb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __add__(s, t): - cdef long cap - if not isinstance(t, arb_series): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - u = arb_series.__new__(arb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - arb_poly_add((u).val, (s).val, (t).val, getprec()) - arb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __radd__(s, t): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - cdef long cap - if not isinstance(t, arb_series): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - u = arb_series.__new__(arb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - arb_poly_sub((u).val, (s).val, (t).val, getprec()) - arb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __rsub__(s, t): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def __mul__(s, t): - cdef long cap - if not isinstance(t, arb_series): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - u = arb_series.__new__(arb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - arb_poly_mul((u).val, (s).val, (t).val, getprec()) - arb_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __rmul__(s, t): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - cpdef valuation(self): - cdef long i - if self.length() == 0: - return -1 - i = 0 - while arb_is_zero(&(self.val.coeffs[i])): - i += 1 - return i - - def __truediv__(s, t): - cdef long cap, sval, tval - cdef arb_poly_t stmp, ttmp - if not isinstance(t, arb_series): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s / t - - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - - if (t).length() == 0: - raise ZeroDivisionError("power series division") - - u = arb_series.__new__(arb_series) - - if (s).length() == 0: - u.cap = cap - return u - - sval = (s).valuation() - tval = (t).valuation() - - if sval < tval: - raise ValueError("quotient would not be a power series") - - if not arb_is_nonzero(&((t).val.coeffs[tval])): - raise ValueError("leading term in denominator is not nonzero") - - if tval == 0: - arb_poly_div_series((u).val, (s).val, (t).val, cap, getprec()) - else: - arb_poly_init(stmp) - arb_poly_init(ttmp) - arb_poly_shift_right(stmp, (s).val, tval) - arb_poly_shift_right(ttmp, (t).val, tval) - cap -= tval - arb_poly_div_series((u).val, stmp, ttmp, cap, getprec()) - arb_poly_clear(stmp) - arb_poly_clear(ttmp) - - (u)._prec = cap - return u - - def __rtruediv__(s, t): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t / s - - def __pow__(s, t, mod): - cdef long cap - if mod is not None: - raise NotImplementedError("modular exponentiation") - if not isinstance(t, arb_series): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s ** t - - u = arb_series.__new__(arb_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - arb_poly_pow_series((u).val, (s).val, (t).val, cap, getprec()) - (u)._prec = cap - return u - - def __rpow__(s, t, mod): - s, t = arb_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t ** s - - def __call__(s, t): - cdef long cap - if typecheck(t, arb_series): - u = arb_series.__new__(arb_series) - if (t).valuation() < 1: - raise ValueError("power series composition with nonzero constant term") - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - arb_poly_compose_series((u).val, (s).val, (t).val, cap, getprec()) - (u)._prec = cap - return u - raise TypeError("cannot call arb_series with input of type %s", type(t)) - - def reversion(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if s.length() < 2 or (not arb_is_zero(&s.val.coeffs[0])) or \ - (not arb_is_nonzero(&s.val.coeffs[1])): - raise ValueError("power series reversion requires valuation 1") - u = arb_series.__new__(arb_series) - arb_poly_revert_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def inv(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if s.length() == 0: - raise ZeroDivisionError - u = arb_series.__new__(arb_series) - arb_poly_inv_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def derivative(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec - 1) - u = arb_series.__new__(arb_series) - arb_poly_derivative((u).val, (s).val, getprec()) - arb_poly_truncate((u).val, max(0, cap)) - (u)._prec = cap - return u - - def integral(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec + 1) - u = arb_series.__new__(arb_series) - arb_poly_integral((u).val, (s).val, getprec()) - arb_poly_truncate((u).val, max(0, cap)) - (u)._prec = cap - return u - - def sqrt(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_sqrt_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def rsqrt(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_rsqrt_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def exp(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_exp_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def log(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_log_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def atan(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_atan_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def asin(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_asin_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def acos(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_acos_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def sin(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_sin_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def cos(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_cos_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def sin_cos(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - v = arb_series.__new__(arb_series) - arb_poly_sin_cos_series((u).val, (v).val, (s).val, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - return u, v - - def sin_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_sin_pi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def cos_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_cos_pi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def sin_cos_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - v = arb_series.__new__(arb_series) - arb_poly_sin_cos_pi_series((u).val, (v).val, (s).val, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - return u, v - - def cot_pi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_cot_pi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def tan(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_tan_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def gamma(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_gamma_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def rgamma(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_rgamma_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def lgamma(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_lgamma_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def rising(s, ulong n): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_rising_ui_series((u).val, (s).val, n, cap, getprec()) - (u)._prec = cap - return u - - def zeta(s, a=1, bint deflate=0): - cdef long cap - a = arb(a) - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_zeta_series((u).val, (s).val, (a).val, deflate, cap, getprec()) - (u)._prec = cap - return u - - def riemann_siegel_theta(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_riemann_siegel_theta_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def riemann_siegel_z(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_riemann_siegel_z_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def erf(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_erf_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def erfc(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_erfc_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def erfi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_erfi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def fresnel(s, bint normalized=True): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - v = arb_series.__new__(arb_series) - arb_hypgeom_fresnel_series((u).val, (v).val, (s).val, normalized, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - return u, v - - def fresnel_s(s, bint normalized=True): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_fresnel_series((u).val, NULL, (s).val, normalized, cap, getprec()) - (u)._prec = cap - return u - - def fresnel_c(s, bint normalized=True): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_fresnel_series(NULL, (u).val, (s).val, normalized, cap, getprec()) - (u)._prec = cap - return u - - def ei(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_ei_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def si(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_si_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def ci(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_ci_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def shi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_shi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def chi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_chi_series((u).val, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def li(s, bint offset=False): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_li_series((u).val, (s).val, offset, cap, getprec()) - (u)._prec = cap - return u - - def airy_ai(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_airy_series((u).val, NULL, NULL, NULL, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy_ai_prime(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_airy_series(NULL, (u).val, NULL, NULL, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy_bi(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_airy_series(NULL, NULL, (u).val, NULL, (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy_bi_prime(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_airy_series(NULL, NULL, NULL, (u).val, - (s).val, cap, getprec()) - (u)._prec = cap - return u - - def airy(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - v = arb_series.__new__(arb_series) - w = arb_series.__new__(arb_series) - z = arb_series.__new__(arb_series) - arb_hypgeom_airy_series((u).val, (v).val, (w).val, (z).val, (s).val, cap, getprec()) - (u)._prec = cap - (v)._prec = cap - (w)._prec = cap - (z)._prec = cap - return u, v, w, z - - def coulomb(self, l, eta): - cdef long cap - l = arb(l) - eta = arb(eta) - cap = getcap() - cap = min(cap, (self)._prec) - F = arb_series.__new__(arb_series) - G = arb_series.__new__(arb_series) - arb_hypgeom_coulomb_series((F).val, (G).val, - (l).val, (eta).val, (self).val, cap, getprec()) - (F)._prec = cap - (G)._prec = cap - return F, G - - def coulomb_f(self, l, eta): - cdef long cap - l = arb(l) - eta = arb(eta) - cap = getcap() - cap = min(cap, (self)._prec) - F = arb_series.__new__(arb_series) - arb_hypgeom_coulomb_series((F).val, NULL, - (l).val, (eta).val, (self).val, cap, getprec()) - (F)._prec = cap - return F - - def coulomb_g(self, l, eta): - cdef long cap - l = arb(l) - eta = arb(eta) - cap = getcap() - cap = min(cap, (self)._prec) - G = arb_series.__new__(arb_series) - arb_hypgeom_coulomb_series(NULL, (G).val, - (l).val, (eta).val, (self).val, cap, getprec()) - (G)._prec = cap - return G - - @classmethod - def gamma_upper(cls, s, z, int regularized=0): - cdef long cap - s = arb(s) - z = arb_series(z) - cap = getcap() - cap = min(cap, (z)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_gamma_upper_series((u).val, (s).val, (z).val, regularized, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def gamma_lower(cls, s, z, int regularized=0): - cdef long cap - s = arb(s) - z = arb_series(z) - cap = getcap() - cap = min(cap, (z)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_gamma_lower_series((u).val, (s).val, (z).val, regularized, cap, getprec()) - (u)._prec = cap - return u - - @classmethod - def beta_lower(cls, a, b, z, int regularized=0): - cdef long cap - a = arb(a) - b = arb(b) - z = arb_series(z) - cap = getcap() - cap = min(cap, (z)._prec) - u = arb_series.__new__(arb_series) - arb_hypgeom_beta_lower_series((u).val, (a).val, (b).val, (z).val, regularized, cap, getprec()) - (u)._prec = cap - return u - - def lambertw(s, int branch=0): - cdef int flags - cdef long cap - if branch == 0: - flags = 0 - elif branch == -1: - flags = 1 - else: - raise ValueError("invalid branch") - cap = getcap() - cap = min(cap, (s)._prec) - u = arb_series.__new__(arb_series) - arb_poly_lambertw_series((u).val, (s).val, flags, cap, getprec()) - (u)._prec = cap - return u - - @staticmethod - def find_roots(f, a, b, maxn=100000): - """ - Isolates the roots of a given real analytic function *f* on the - interval [*a*, *b*]. The function *f* takes an *arb_series* as input - and outputs an *arb_series*. - - This is just a test implementation; more options including support - for Newton refinement will be added in a future version. - - >>> from flint import arb_series, ctx - >>> ctx.prec = 53 - >>> for c in arb_series.find_roots(lambda x: x.sin(), -8, 8): print(c) - ... - (-6.96875000000000, -5.93750000000000) - (-3.87500000000000, -1.81250000000000) - (-0.781250000000000, 0.250000000000000) - (2.18750000000000, 4.12500000000000) - (6.06250000000000, 7.03125000000000) - >>> for c in arb_series.find_roots(lambda x: x.riemann_siegel_z(), 0, 30): print(c) - ... - (14.1210937500000, 14.1796875000000) - (20.9765625000000, 21.0351562500000) - (24.9609375000000, 25.0195312500000) - - """ - orig_cap = ctx.cap - - def xsgn(x): - if x < 0: - return -1 - if x > 0: - return 1 - return 0 - try: - roots = [] - ctx.cap = 1 - queue = [(arb(a), arb(b))] - qvals = [(xsgn(f(arb_series(a))[0]), xsgn(f(arb_series(b))[0]))] - if 0 in qvals[0]: - raise ValueError("unknown sign at an endpoint; try a slightly larger interval") - n = 0 - while queue: - n += 1 - if n >= maxn: - raise ValueError("failed to converge") - a, b = queue.pop() - fa, fb = qvals.pop() - m, r = (a+b)/2, (b-a)/2 - ctx.cap = 1 - v = f(arb_series([arb(m, r)])) - if v[0] != 0: - continue - ctx.cap = 2 - if fa * fb < 0 and f(arb_series([arb(m, r), 1]))[1] != 0: - roots.append((a, b)) - continue - ctx.cap = 1 - fm = xsgn(f(arb_series(m))[0]) - if fm == 0: - m = a + (b-a)*(33/64.) - fm = xsgn(f(arb_series(m))[0]) - if fm == 0: - raise ValueError("unknown sign at a bisection point") - queue.append((m, b)) - qvals.append((fm, fb)) - queue.append((a, m)) - qvals.append((fa, fm)) - finally: - ctx.cap = orig_cap - return roots diff --git a/src/flint/types/arf.pxd b/src/flint/types/arf.pxd deleted file mode 100644 index 5fcdc898..00000000 --- a/src/flint/types/arf.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flintlib.functions.arf cimport arf_t - -cdef class arf: - cdef arf_t val - cpdef bint is_finite(self) - cpdef bint is_pos_inf(self) - cpdef bint is_neg_inf(self) - cpdef bint is_nan(self) - cpdef bint is_zero(self) diff --git a/src/flint/types/arf.pyx b/src/flint/types/arf.pyx deleted file mode 100644 index d4dbea42..00000000 --- a/src/flint/types/arf.pyx +++ /dev/null @@ -1,188 +0,0 @@ -from cpython.float cimport PyFloat_AsDouble -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_context cimport thectx -from flint.utils.typecheck cimport typecheck -from flint.utils.conversion cimport prec_to_dps -from flint.types.fmpz cimport fmpz -from flint.types.fmpz cimport any_as_fmpz -from flint.types.arb cimport arb - -from flint.flintlib.functions.arf cimport * - -ctx = thectx - -cdef class arf: - - # cdef arf_t val - - def __cinit__(self): - arf_init(self.val) - - def __dealloc__(self): - arf_clear(self.val) - - def __init__(self, val=None): - """ - Create a new arf from an integer, a Python float, an existing arf, - or a tuple containing (mantissa, exponent):: - - >>> from flint import arf, ctx - >>> ctx.prec = 53 - >>> arf(-100) - -100.000000000000 - >>> arf(15.125) - 15.1250000000000 - >>> arf(arf(3)) - 3.00000000000000 - >>> arf((10,-2)) - 2.50000000000000 - - """ - if val is not None: - if typecheck(val, fmpz): - arf_set_fmpz(self.val, (val).val) - elif typecheck(val, arf): - arf_set(self.val, (val).val) - elif typecheck(val, float): - arf_set_d(self.val, PyFloat_AsDouble(val)) - elif typecheck(val, tuple): - man = any_as_fmpz(val[0]) - exp = any_as_fmpz(val[1]) - if man is NotImplemented or exp is NotImplemented: - raise TypeError("cannot create arf from tuple (%s, %s)" % (type(val[0]), type(val[1]))) - arf_set_fmpz_2exp(self.val, (man).val, (exp).val) - elif typecheck(val, str): - if val == "+inf" or val == "inf": - arf_pos_inf(self.val) - elif val == "-inf": - arf_neg_inf(self.val) - elif val == "nan": - arf_nan(self.val) - else: - raise TypeError("cannot create arf from type %s" % type(val)) - else: - v = any_as_fmpz(val) - if v is not NotImplemented: - arf_set_fmpz(self.val, (v).val) - else: - raise TypeError("cannot create arf from type %s" % type(val)) - - cpdef bint is_finite(self): - return arf_is_finite(self.val) - - cpdef bint is_pos_inf(self): - return arf_is_pos_inf(self.val) - - cpdef bint is_neg_inf(self): - return arf_is_neg_inf(self.val) - - cpdef bint is_nan(self): - return arf_is_nan(self.val) - - cpdef bint is_zero(self): - return arf_is_zero(self.val) - - # todo: exception when not finite! - def man_exp(self): - cdef fmpz man, exp - man = fmpz() - exp = fmpz() - arf_get_fmpz_2exp(man.val, exp.val, self.val) - return man, exp - - def _repr_str(self): - if arf_is_zero(self.val): - return "0.0" - elif arf_is_finite(self.val): - man, exp = self.man_exp() - return "(%s, %s)" % (hex(man), hex(exp)) - elif arf_is_pos_inf(self.val): - return "'+inf'" - elif arf_is_neg_inf(self.val): - return "'-inf'" - else: - return "'nan'" - - def _dec_str(self, num_digits=None): - if arf_is_normal(self.val): - if num_digits is None: - num_digits = prec_to_dps(getprec()) - return arb(self).str(num_digits, radius=False) - elif arf_is_zero(self.val): - return "0.0" - elif arf_is_pos_inf(self.val): - return "inf" - elif arf_is_neg_inf(self.val): - return "-inf" - else: - return "nan" - - def __repr__(self): - if ctx.pretty: - return str(self) - return "arf(%s)" % self._repr_str() - - def __str__(self): - return self._dec_str() - - def __richcmp__(s, t, int op): - cdef bint res = 0 - if not typecheck(t, arf): - t = arf(t) - if op == 2: - res = arf_equal((s).val, (t).val) - elif op == 3: - res = not arf_equal((s).val, (t).val) - elif op == 0: - res = arf_cmp((s).val, (t).val) < 0 - elif op == 1: - res = arf_cmp((s).val, (t).val) <= 0 - elif op == 4: - res = arf_cmp((s).val, (t).val) > 0 - elif op == 5: - res = arf_cmp((s).val, (t).val) >= 0 - return res - - def __pos__(self): - res = arf.__new__(arf) - arf_set_round((res).val, (self).val, getprec(), thectx.rnd) - return res - - def __neg__(self): - res = arf.__new__(arf) - arf_neg_round((res).val, (self).val, getprec(), thectx.rnd) - return res - - def __abs__(self): - res = arf.__new__(arf) - arf_abs((res).val, (self).val) - arf_set_round((res).val, (res).val, getprec(), thectx.rnd) - return res - - def __add__(s, t): - if not typecheck(t, arf): - return NotImplemented - u = arf.__new__(arf) - arf_add((u).val, (s).val, (t).val, getprec(), thectx.rnd) - return u - - def __sub__(s, t): - if not typecheck(t, arf): - return NotImplemented - u = arf.__new__(arf) - arf_sub((u).val, (s).val, (t).val, getprec(), thectx.rnd) - return u - - def __mul__(s, t): - if not typecheck(t, arf): - return NotImplemented - u = arf.__new__(arf) - arf_mul((u).val, (s).val, (t).val, getprec(), thectx.rnd) - return u - - def __div__(s, t): - if not typecheck(t, arf): - return NotImplemented - u = arf.__new__(arf) - arf_div((u).val, (s).val, (t).val, getprec(), thectx.rnd) - return u diff --git a/src/flint/types/dirichlet.pxd b/src/flint/types/dirichlet.pxd deleted file mode 100644 index 3ebffc72..00000000 --- a/src/flint/types/dirichlet.pxd +++ /dev/null @@ -1,13 +0,0 @@ -from flint.flintlib.functions.dirichlet cimport dirichlet_group_t -from flint.flintlib.functions.dirichlet cimport dirichlet_char_t - -cdef class dirichlet_group(object): - cdef dirichlet_group_t val - cdef int _init - - cpdef long size(self) - -cdef class dirichlet_char(object): - - cdef dirichlet_char_t val - cdef dirichlet_group G diff --git a/src/flint/types/dirichlet.pyx b/src/flint/types/dirichlet.pyx deleted file mode 100644 index de58790e..00000000 --- a/src/flint/types/dirichlet.pyx +++ /dev/null @@ -1,217 +0,0 @@ -from flint.flint_base.flint_context cimport getprec -from flint.types.acb cimport any_as_acb -from flint.types.acb cimport acb -from flint.types.fmpz cimport fmpz - -from flint.flintlib.functions.ulong_extras cimport n_gcd -from flint.flintlib.functions.fmpz cimport fmpz_get_ui -from flint.flintlib.functions.dirichlet cimport * -from flint.flintlib.types.dirichlet cimport DIRICHLET_CHI_NULL -from flint.flintlib.functions.acb_dirichlet cimport * - -cdef dict _dirichlet_group_cache = {} - -cdef class dirichlet_group(object): - """ - Represents the group of Dirichlet characters modulo a given q. - - >>> G = dirichlet_group(5) - >>> G - Dirichlet group mod q = 5 - """ - - # cdef dirichlet_group_t val - # cdef int _init - - def __cinit__(self): - self._init = 0 - - def __dealloc__(self): - if self._init != 0: - dirichlet_group_clear(self.val) - - def __init__(self, ulong q): - assert q >= 1 - dirichlet_group_init(self.val, q) - self._init = 1 - - cpdef long size(self): - return dirichlet_group_size(self.val) - - @property - def q(self): - return fmpz(self.val.q) - - def exponent(self): - return fmpz(self.val.expo) - - def __repr__(self): - return "Dirichlet group mod q = %s" % self.q - - def __str__(self): - return repr(self) - - -cdef class dirichlet_char(object): - """ - Represents a Dirichlet character. - - Calling the character evaluates the character at the - given integer, returning an acb. - - >>> from flint import dirichlet_char, ctx - >>> ctx.prec = 53 - >>> chi = dirichlet_char(7, 1) - >>> for n in range(7): - ... print(chi(n)) - ... - 0 - 1.00000000000000 - 1.00000000000000 - 1.00000000000000 - 1.00000000000000 - 1.00000000000000 - 1.00000000000000 - >>> chi = dirichlet_char(7, 3) - >>> for n in range(7): - ... print(chi(n)) - ... - 0 - 1.00000000000000 - -0.500000000000000 + [0.866025403784439 +/- 5.15e-16]j - 0.500000000000000 + [0.866025403784439 +/- 5.15e-16]j - -0.500000000000000 + [-0.866025403784439 +/- 5.15e-16]j - 0.500000000000000 + [-0.866025403784439 +/- 5.15e-16]j - -1.00000000000000 - """ - - # cdef dirichlet_char_t val - # cdef dirichlet_group G - - def __cinit__(self): - pass - - def __dealloc__(self): - dirichlet_char_clear(self.val) - - def __init__(self, ulong q, ulong l=1): - """ - Creates the Dirichlet character with Conrey number (q, l). - - >>> chi = dirichlet_char(5, 1) - - """ - if q in _dirichlet_group_cache: - G = _dirichlet_group_cache[q] - else: - G = dirichlet_group(q) - _dirichlet_group_cache[q] = G - self.G = G - dirichlet_char_init(self.val, self.G.val) - assert 1 <= l <= max(q, 2)-1 and n_gcd(q, l) == 1 - dirichlet_char_log(self.val, self.G.val, l) - - def group(self): - return self.G - - def index(self): - return dirichlet_index_char(self.G.val, self.val) - - def modulus(self): - return self.G.q - - def number(self): - return dirichlet_char_exp(self.G.val, self.val) - - def order(self): - return dirichlet_order_char(self.G.val, self.val) - - def is_real(self): - return bool(dirichlet_char_is_real(self.G.val, self.val)) - - def is_primitive(self): - return bool(dirichlet_char_is_primitive(self.G.val, self.val)) - - def conductor(self): - return dirichlet_conductor_char(self.G.val, self.val) - - def is_principal(self): - return bool(dirichlet_char_is_principal(self.G.val, self.val)) - - def parity(self): - return dirichlet_parity_char(self.G.val, self.val) - - def __repr__(self): - return "dirichlet_char(%i, %i)" % (self.modulus(), self.number()) - - def __str__(self): - return repr(self) - - def __mul__(dirichlet_char self, dirichlet_char other): - cdef dirichlet_char res - assert self.G.q == other.G.q - res = dirichlet_char(self.G.q, 1) - dirichlet_char_mul(res.val, self.G.val, self.val, other.val) - return res - - def __call__(self, n): - cdef acb v - cdef fmpz m - m = fmpz(n) % self.G.q - v = acb.__new__(acb) - acb_dirichlet_chi((v).val, self.G.val, self.val, fmpz_get_ui(m.val), getprec()) - return v - - def chi_exponent(self, n): - cdef fmpz m - cdef ulong v - m = fmpz(n) % self.G.q - v = dirichlet_chi(self.G.val, self.val, fmpz_get_ui(m.val)) - if v == DIRICHLET_CHI_NULL: - return None - else: - return fmpz(v) - - def l_function(self, s): - """ - Evaluates the Dirichlet L-function of this character at the given - complex number s. - - >>> from flint import showgood - >>> chi = dirichlet_char(1, 1) - >>> showgood(lambda: chi.l_function(2), dps=25) - 1.644934066848226436472415 - >>> chi = dirichlet_char(7, 3) - >>> showgood(lambda: chi.l_function(2+3j), dps=25) - 1.273313649440490751755284 - 0.07432329442559421607102118j - - """ - s = any_as_acb(s) - cdef acb v - v = acb.__new__(acb) - acb_dirichlet_l((v).val, (s).val, self.G.val, self.val, getprec()) - return v - - # For backwards compatibility we allow self.l(s) see Issue #210 - def l(self, s): # no-cython-lint - """ - Alias for :meth:`l_function` - """ - return self.l_function(s) - - def hardy_z(self, s): - """ - Evaluates the Hardy Z-function of this character at the given - complex number s. - - >>> chi = dirichlet_char(1, 1) - >>> from flint import showgood - >>> showgood(lambda: chi.hardy_z(1), dps=25) - -0.7363054628673177346778998 - - """ - s = any_as_acb(s) - cdef acb v - v = acb.__new__(acb) - acb_dirichlet_hardy_z((v).val, (s).val, self.G.val, self.val, 1, getprec()) - return v diff --git a/src/flint/types/fmpq.pxd b/src/flint/types/fmpq.pxd deleted file mode 100644 index f421b679..00000000 --- a/src/flint/types/fmpq.pxd +++ /dev/null @@ -1,8 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.flintlib.functions.fmpq cimport fmpq_t - -cdef int fmpq_set_any_ref(fmpq_t x, obj) -cdef any_as_fmpq(obj) - -cdef class fmpq(flint_scalar): - cdef fmpq_t val diff --git a/src/flint/types/fmpq.pyi b/src/flint/types/fmpq.pyi deleted file mode 100644 index 269fe2c6..00000000 --- a/src/flint/types/fmpq.pyi +++ /dev/null @@ -1,95 +0,0 @@ -from ..flint_base.flint_base import flint_scalar -from typing import overload -from .fmpz import fmpz - - -_str = str -ifmpz = int | fmpz -ifmpq = int | fmpz | fmpq - - -class fmpq(flint_scalar): - @overload - def __init__(self) -> None: ... - @overload - def __init__(self, arg: ifmpq | _str, /) -> None: ... - @overload - def __init__(self, num: ifmpq, den: ifmpq, /): ... - - @property - def p(self) -> fmpz: ... - @property - def q(self) -> fmpz: ... - - @property - def numerator(self) -> fmpz: ... - @property - def denominator(self) -> fmpz: ... - - def numer(self) -> fmpz: ... - def denom(self) -> fmpz: ... - - def height_bits(self, signed: bool = False) -> int: ... - - def next(self, signed: bool = True, minimal: bool = True) -> fmpq: ... - - def str(self, base: int = 10, condense: int = 0) -> _str: ... - def repr(self) -> _str: ... - - def __str__(self) -> _str: ... - def __repr__(self) -> _str: ... - - def __int__(self) -> int: ... - def __float__(self) -> float: ... - - def __floor__(self) -> fmpz: ... - def __ceil__(self) -> fmpz: ... - def __trunc__(self) -> fmpz: ... - - def floor(self) -> fmpz: ... - def ceil(self) -> fmpz: ... - - @overload - def __round__(self, ndigits: int) -> fmpq: ... - @overload - def __round__(self) -> fmpz: ... - - def __eq__(self, other: object, /) -> bool: ... - def __hash__(self) -> int: ... - - def __lt__(self, other: ifmpq, /) -> bool: ... - def __le__(self, other: ifmpq, /) -> bool: ... - def __gt__(self, other: ifmpq, /) -> bool: ... - def __ge__(self, other: ifmpq, /) -> bool: ... - - def __neg__(self) -> fmpq: ... - def __pos__(self) -> fmpq: ... - def __add__(self, other: ifmpq, /) ->fmpq: ... - def __radd__(self, other: ifmpz, /) ->fmpq: ... - def __sub__(self, other: ifmpq, /) ->fmpq: ... - def __rsub__(self, other: ifmpz, /) ->fmpq: ... - def __mul__(self, other: ifmpq, /) ->fmpq: ... - def __rmul__(self, other: ifmpz, /) ->fmpq: ... - def __truediv__(self, other: ifmpq, /) ->fmpq: ... - def __rtruediv__(self, other: ifmpz, /) ->fmpq: ... - def __floordiv__(self, other: ifmpq, /) ->fmpq: ... - def __rfloordiv__(self, other: ifmpz, /) ->fmpq: ... - def __mod__(self, other: ifmpq, /) ->fmpq: ... - def __rmod__(self, other: ifmpz, /) ->fmpq: ... - def __divmod__(self, other: ifmpq, /) -> tuple[fmpq,fmpq]: ... - def __rdivmod__(self, other: ifmpz, /) -> tuple[fmpq,fmpq]: ... - def __pow__(self, other: ifmpz, /) ->fmpq: ... - def __abs__(self) ->fmpq: ... - - def gcd(self, other: ifmpq, /) -> fmpq: ... - - def sqrt(self) -> fmpq: ... - - @staticmethod - def bernoulli(n: int, cache: bool = False) -> fmpq: ... - - @staticmethod - def harmonic(n: int) -> fmpq: ... - - @staticmethod - def dedekind_sum(n: ifmpz, k: ifmpz) -> fmpq: ... diff --git a/src/flint/types/fmpq.pyx b/src/flint/types/fmpq.pyx deleted file mode 100644 index ef4fdb5d..00000000 --- a/src/flint/types/fmpq.pyx +++ /dev/null @@ -1,550 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.utils.typecheck cimport typecheck -from flint.types.fmpz cimport fmpz_set_any_ref -from flint.types.fmpz cimport fmpz_get_intlong -from flint.types.fmpz cimport fmpz -from flint.types.fmpz cimport any_as_fmpz - -from flint.flintlib.types.flint cimport FMPZ_UNKNOWN, FMPZ_TMP, FMPZ_REF -from flint.flintlib.functions.fmpz cimport fmpz_set, fmpz_one -from flint.flintlib.functions.fmpz cimport fmpz_is_zero, fmpz_sgn -from flint.flintlib.functions.fmpz cimport fmpz_fdiv_q, fmpz_bits -from flint.flintlib.functions.fmpz cimport fmpz_cdiv_q -from flint.flintlib.functions.fmpz cimport fmpz_tdiv_q -from flint.flintlib.functions.fmpz cimport fmpz_clear -from flint.flintlib.functions.fmpq cimport * -from flint.flintlib.functions.bernoulli cimport * - -cdef int fmpq_set_any_ref(fmpq_t x, obj): - cdef int status - fmpq_init(x) - if typecheck(obj, fmpq): - x[0] = (obj).val[0] - return FMPZ_REF - if typecheck(obj, fmpz): - fmpz_set(fmpq_numref(x), (obj).val) - fmpz_one(fmpq_denref(x)) - return FMPZ_TMP - status = fmpz_set_any_ref(fmpq_numref(x), obj) - if status != FMPZ_UNKNOWN: - fmpz_one(fmpq_denref(x)) - return FMPZ_TMP - fmpq_clear(x) - return FMPZ_UNKNOWN - -cdef any_as_fmpq(obj): - cdef fmpq_t x - cdef int status - cdef fmpq q - status = fmpq_set_any_ref(x, obj) - if status == FMPZ_REF: - q = fmpq.__new__(fmpq) - fmpq_set(q.val, x) - return q - elif status == FMPZ_TMP: - q = fmpq.__new__(fmpq) - fmpq_clear(q.val) - q.val[0] = x[0] - return q - else: - return NotImplemented - -cdef class fmpq(flint_scalar): - """ - The fmpq type represents multiprecision rational numbers. - - >>> fmpq(1,7) + fmpq(50,51) - 401/357 - - """ - -# cdef fmpq_t val - - def __cinit__(self): - fmpq_init(self.val) - - def __dealloc__(self): - fmpq_clear(self.val) - - def __init__(self, *args): - if not args: - return # zero - elif len(args) == 2: - p, q = args - elif len(args) == 1: - p = args[0] - if typecheck(p, fmpq): - fmpq_set(self.val, (p).val) - return - elif typecheck(p, str): - if "/" in p: - p, q = p.split("/") - p = fmpz(p) - q = fmpz(q) - else: - p = fmpz(p) - q = fmpz(1) - else: - p2 = any_as_fmpq(p) - if p2 is NotImplemented: - raise TypeError("cannot create fmpq from object of type %s" % type(p)) - fmpq_set(self.val, (p2).val) - return - else: - raise TypeError("fmpq() takes at most 2 arguments (%d given)" % len(args)) - - p2 = any_as_fmpz(p) - if p2 is NotImplemented: - # Allow fmpq(fmpq, fmpq/fmpz) - p2 = any_as_fmpq(p) - if p2 is NotImplemented: - raise TypeError("cannot create fmpz/fmpq from object of type %s" % type(p)) - q2 = any_as_fmpq(q) - if q2 is NotImplemented: - raise TypeError("cannot create fmpz/fmpq from object of type %s" % type(q)) - p3 = p2 / q2 - fmpq_set(self.val, (p3).val) - return - - q2 = any_as_fmpz(q) - if q2 is NotImplemented: - # fmpq(fmpz, fmpq) - q2 = any_as_fmpq(q) - if q2 is NotImplemented: - raise TypeError("cannot create fmpz/fmpq from object of type %s" % type(q)) - p3 = p2 / q2 - fmpq_set(self.val, (p3).val) - return - - if fmpz_is_zero((q2).val): - raise ZeroDivisionError("cannot create rational number with zero denominator") - - fmpz_set(fmpq_numref(self.val), (p2).val) - fmpz_set(fmpq_denref(self.val), (q2).val) - fmpq_canonicalise(self.val) - - def __richcmp__(s, t, int op): - cdef bint res - s = any_as_fmpq(s) - if s is NotImplemented: - return s - t = any_as_fmpq(t) - if t is NotImplemented: - return t - if op == 2 or op == 3: - res = fmpq_equal((s).val, (t).val) - if op == 3: - res = not res - return res - else: - # todo: use fmpq_cmp when available - if op == 0: - res = (s-t).p < 0 - elif op == 1: - res = (s-t).p <= 0 - elif op == 4: - res = (s-t).p > 0 - elif op == 5: - res = (s-t).p >= 0 - else: - raise ValueError - return res - - def numer(self): - """ - Returns the numerator of *self* as an *fmpz*. - """ - cdef fmpz x = fmpz.__new__(fmpz) - fmpz_set(x.val, fmpq_numref(self.val)) - return x - - def denom(self): - """ - Returns the denominator of *self* as an *fmpz*. - """ - cdef fmpz x = fmpz.__new__(fmpz) - fmpz_set(x.val, fmpq_denref(self.val)) - return x - - p = property(numer) - q = property(denom) - - # These are the property names in the numeric tower. - numerator = property(numer) - denominator = property(denom) - - def __reduce__(self): - return (fmpq, (int(self.p), int(self.q))) - - def repr(self): - if self.q == 1: - return "fmpq(%s)" % self.p - else: - return "fmpq(%s,%s)" % (self.p, self.q) - - def str(self, **kwargs): - """ - Converts *self* to a string, forwarding optional keyword arguments - to :meth:`.fmpz.str`. - - >>> fmpq.bernoulli(12).str() - '-691/2730' - >>> fmpq.bernoulli(100).str(base=2, condense=10) - '-110001110{...257 digits...}0011011111/1000001000110010' - """ - if self.q == 1: - return self.p.str(**kwargs) - else: - return "%s/%s" % (self.p.str(**kwargs), self.q.str(**kwargs)) - - def __int__(self): - return int(self.trunc()) - - def __float__(self) -> float: - n = fmpz_get_intlong(fmpq_numref(self.val)) - d = fmpz_get_intlong(fmpq_denref(self.val)) - return n / d - - def __floor__(self): - return self.floor() - - def __ceil__(self): - return self.ceil() - - def __trunc__(self): - return self.trunc() - - def __bool__(self): - return not fmpq_is_zero(self.val) - - def __round__(self, ndigits=None): - return self.round(ndigits) - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpq r = fmpq.__new__(fmpq) - fmpq_neg(r.val, self.val) - return r - - def __abs__(self): - cdef fmpq r - if fmpz_sgn(fmpq_numref(self.val)) >= 0: - return self - r = fmpq.__new__(fmpq) - fmpq_neg(r.val, self.val) - return r - - def __add__(s, t): - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - return t - r = fmpq.__new__(fmpq) - fmpq_add(r.val, (s).val, (t).val) - return r - - def __radd__(s, t): - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - return t - r = fmpq.__new__(fmpq) - fmpq_add(r.val, (t).val, (s).val) - return r - - def __sub__(s, t): - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - return t - r = fmpq.__new__(fmpq) - fmpq_sub(r.val, (s).val, (t).val) - return r - - def __rsub__(s, t): - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - return t - r = fmpq.__new__(fmpq) - fmpq_sub(r.val, (t).val, (s).val) - return r - - def __mul__(s, t): - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - return t - r = fmpq.__new__(fmpq) - fmpq_mul(r.val, (s).val, (t).val) - return r - - def __rmul__(s, t): - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - return t - r = fmpq.__new__(fmpq) - fmpq_mul(r.val, (t).val, (s).val) - return r - - @staticmethod - def _div_(s, t): - cdef fmpq r - s = any_as_fmpq(s) - if s is NotImplemented: - return s - t = any_as_fmpq(t) - if t is NotImplemented: - return t - if fmpq_is_zero((t).val): - raise ZeroDivisionError("fmpq division by zero") - r = fmpq.__new__(fmpq) - fmpq_div(r.val, (s).val, (t).val) - return r - - def __truediv__(s, t): - return fmpq._div_(s, t) - - def __rtruediv__(s, t): - return fmpq._div_(t, s) - - def gcd(s, t): - """GCD of two rational numbers. - - >>> fmpq(1,2).gcd(fmpq(3,4)) - 1/4 - - The GCD is defined as the GCD of the numerators divided by the LCM of - the denominators. This is consistent with ``fmpz.gcd()`` but not with - ``fmpq_poly.gcd()``. - """ - cdef fmpq r - t = any_as_fmpq(t) - if t is NotImplemented: - raise TypeError("fmpq expected") - r = fmpq.__new__(fmpq) - fmpq_gcd(r.val, (s).val, (t).val) - return r - - def next(s, bint signed=True, bint minimal=True): - """ - Returns the next rational number after *s* as ordered by - minimal height (if *minimal* is True) or following the Calkin-Wilf - sequence (if *minimal* is False). If *signed* is set to False, - only the nonnegative rational numbers are considered. - - >>> fmpq(23456789,98765432).next() - -23456789/98765432 - >>> fmpq(23456789,98765432).next(signed=False) - 98765432/23456789 - >>> fmpq(23456789,98765432).next(signed=False, minimal=False) - 98765432/75308643 - >>> a, b, c, d = [fmpq(0)], [fmpq(0)], [fmpq(0)], [fmpq(0)] - >>> for i in range(20): - ... a.append(a[-1].next()) - ... b.append(b[-1].next(signed=False)) - ... c.append(c[-1].next(minimal=False)) - ... d.append(d[-1].next(signed=False, minimal=False)) - ... - >>> a - [0, 1, -1, 1/2, -1/2, 2, -2, 1/3, -1/3, 3, -3, 2/3, -2/3, 3/2, -3/2, 1/4, -1/4, 4, -4, 3/4, -3/4] - >>> b - [0, 1, 1/2, 2, 1/3, 3, 2/3, 3/2, 1/4, 4, 3/4, 4/3, 1/5, 5, 2/5, 5/2, 3/5, 5/3, 4/5, 5/4, 1/6] - >>> c - [0, 1, -1, 1/2, -1/2, 2, -2, 1/3, -1/3, 3/2, -3/2, 2/3, -2/3, 3, -3, 1/4, -1/4, 4/3, -4/3, 3/5, -3/5] - >>> d - [0, 1, 1/2, 2, 1/3, 3/2, 2/3, 3, 1/4, 4/3, 3/5, 5/2, 2/5, 5/3, 3/4, 4, 1/5, 5/4, 4/7, 7/3, 3/8] - - """ - u = fmpq.__new__(fmpq) - if signed: - if minimal: - fmpq_next_signed_minimal((u).val, (s).val) - else: - fmpq_next_signed_calkin_wilf((u).val, (s).val) - else: - if fmpz_sgn(fmpq_numref(s.val)) < 0: - raise ValueError("s must be nonnegative") - if minimal: - fmpq_next_minimal((u).val, (s).val) - else: - fmpq_next_calkin_wilf((u).val, (s).val) - return u - - @staticmethod - def bernoulli(ulong n, bint cache=False): - """ - Returns the Bernoulli number `B_n` as an *fmpq*. - - >>> [fmpq.bernoulli(n) for n in range(8)] - [1, -1/2, 1/6, 0, -1/30, 0, 1/42, 0] - >>> fmpq.bernoulli(50) - 495057205241079648212477525/66 - - If *cache* is set to *True*, all the Bernoulli numbers up to *n* are - computed and cached for fast subsequent retrieval. This feature should - be used with caution if *n* is large. Calling - :func:`ctx.cleanup()` frees cached Bernoulli numbers. - """ - if cache: - assert n <= 1000000 - bernoulli_cache_compute(n+1) - u = fmpq.__new__(fmpq) - bernoulli_fmpq_ui((u).val, n) - return u - - @staticmethod - def harmonic(ulong n): - """ - Returns the harmonic number `H_n` as an *fmpq*. - - >>> [fmpq.harmonic(n) for n in range(6)] - [0, 1, 3/2, 11/6, 25/12, 137/60] - >>> fmpq.harmonic(50) - 13943237577224054960759/3099044504245996706400 - """ - cdef fmpq v = fmpq() - fmpq_harmonic_ui(v.val, n) - return v - - @staticmethod - def dedekind_sum(n, k): - """ - Dedekind sum. - - >>> fmpq.dedekind_sum(10, 3) - 1/18 - """ - cdef fmpz nv, kv - cdef fmpq v - nv = fmpz(n) - kv = fmpz(k) - v = fmpq() - fmpq_dedekind_sum(v.val, nv.val, kv.val) - return v - - def floor(self): - """ - Floor function. - - >>> fmpq(3,2).floor() - 1 - """ - cdef fmpz r = fmpz.__new__(fmpz) - fmpz_fdiv_q(r.val, fmpq_numref(self.val), fmpq_denref(self.val)) - return r - - def ceil(self): - """ - Ceiling function. - - >>> fmpq(3,2).ceil() - 2 - """ - cdef fmpz r = fmpz.__new__(fmpz) - fmpz_cdiv_q(r.val, fmpq_numref(self.val), fmpq_denref(self.val)) - return r - - def trunc(self): - """ - Truncation function. - - >>> fmpq(3,2).trunc() - 1 - >>> fmpq(-3,2).trunc() - -1 - """ - cdef fmpz r = fmpz.__new__(fmpz) - fmpz_tdiv_q(r.val, fmpq_numref(self.val), fmpq_denref(self.val)) - return r - - def round(self, ndigits=None): - """ - Rounding function. - - >>> fmpq(3,2).round() - 2 - >>> fmpq(-3,2).round() - -2 - """ - from fractions import Fraction - fself = Fraction(int(self.p), int(self.q)) - if ndigits is not None: - fround = round(fself, ndigits) - return fmpq(fround.numerator, fround.denominator) - else: - fround = round(fself) - return fmpz(fround) - - def __hash__(self): - import sys - from fractions import Fraction - if sys.version_info < (3, 12): - return hash(Fraction(int(self.p), int(self.q), _normalize=False)) - else: - return hash(Fraction._from_coprime_ints(int(self.p), int(self.q))) - - def height_bits(self, bint signed=False): - """ - Returns the bit length of the maximum of the numerator and denominator. - With signed=True, returns the negative value if the number is - negative. - - >>> fmpq(1001,5).height_bits() - 10 - >>> fmpq(-5,1001).height_bits(signed=True) - -10 - """ - cdef long b1, b2 - b1 = fmpz_bits(fmpq_numref(self.val)) - b2 = fmpz_bits(fmpq_denref(self.val)) - if signed and fmpz_sgn(fmpq_numref(self.val)) < 0: - return -max(b1, b2) - else: - return max(b1, b2) - - def __pow__(self, n, z): - cdef fmpz_struct nval[1] - cdef int ntype = FMPZ_UNKNOWN - cdef fmpq v - cdef int success - - if z is not None: - raise TypeError("3-arg pow with fmpq is undefined.") - - ntype = fmpz_set_any_ref(nval, n) - if ntype == FMPZ_UNKNOWN: - return NotImplemented - - if fmpq_is_zero((self).val) and fmpz_sgn(nval) == -1: - if ntype == FMPZ_TMP: - fmpz_clear(nval) - raise ZeroDivisionError - - v = fmpq.__new__(fmpq) - success = fmpq_pow_fmpz(v.val, (self).val, nval) - - if ntype == FMPZ_TMP: - fmpz_clear(nval) - - if success: - return v - else: - raise OverflowError("fmpq_pow_fmpz(): exponent too large") - - def sqrt(self): - """ - Return exact rational square root of self or raise an error. - - >>> fmpq(9, 4).sqrt() - 3/2 - >>> fmpq(8).sqrt() - Traceback (most recent call last): - ... - flint.utils.flint_exceptions.DomainError: not a square number - - """ - return fmpq(self.numer().sqrt(), self.denom().sqrt()) diff --git a/src/flint/types/fmpq_mat.pxd b/src/flint/types/fmpq_mat.pxd deleted file mode 100644 index b97e2d4d..00000000 --- a/src/flint/types/fmpq_mat.pxd +++ /dev/null @@ -1,17 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat - -from flint.flintlib.functions.fmpq_mat cimport fmpq_mat_t -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq -from flint.types.fmpz_mat cimport fmpz_mat - -cdef class fmpq_mat(flint_mat): - cdef fmpq_mat_t val - - cpdef long nrows(self) - cpdef long ncols(self) - cdef __mul_fmpz(self, fmpz c) - cdef __mul_fmpq(self, fmpq c) - cdef __mul_fmpq_mat(self, fmpq_mat other) - cdef __mul_fmpz_mat(self, fmpz_mat other) - cdef __mul_r_fmpz_mat(self, fmpz_mat other) diff --git a/src/flint/types/fmpq_mat.pyx b/src/flint/types/fmpq_mat.pyx deleted file mode 100644 index 364e6726..00000000 --- a/src/flint/types/fmpq_mat.pyx +++ /dev/null @@ -1,511 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat -from flint.utils.typecheck cimport typecheck -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.fmpq cimport any_as_fmpq -from flint.types.fmpz cimport any_as_fmpz - -from flint.flintlib.types.fmpq cimport fmpq_mat_struct -from flint.flintlib.functions.fmpz_mat cimport fmpz_mat_nrows, fmpz_mat_ncols -from flint.flintlib.functions.fmpq cimport fmpq_set, fmpq_numref, fmpq_denref -from flint.flintlib.functions.fmpq_poly cimport fmpq_poly_init -from flint.flintlib.functions.fmpq_mat cimport * - -cimport cython - -cdef any_as_fmpq_mat(obj): - if typecheck(obj, fmpq_mat): - return obj - if typecheck(obj, fmpz_mat): - return fmpq_mat(obj) - return NotImplemented - -cdef class fmpq_mat(flint_mat): - """ - Represents a dense matrix over the rational numbers. - >>> from flint import fmpq - >>> A = fmpq_mat(3,3,[1,3,5,2,4,6,fmpq(2,3),2,4]) - >>> A.inv() - [-3, 3/2, 3/2] - [ 3, -1/2, -3] - [-1, 0, 3/2] - >>> A.inv() * A - [1, 0, 0] - [0, 1, 0] - [0, 0, 1] - - """ - - # cdef fmpq_mat_t val - - def __cinit__(self): - fmpq_mat_init(self.val, 0, 0) - - def __dealloc__(self): - fmpq_mat_clear(self.val) - - @cython.embedsignature(False) - def __init__(self, *args): - cdef long m, n, i, j - if len(args) == 1: - val = args[0] - if typecheck(val, fmpq_mat): - fmpq_mat_init(self.val, - fmpq_mat_nrows((val).val), - fmpq_mat_ncols((val).val)) - fmpq_mat_set(self.val, (val).val) - elif typecheck(val, fmpz_mat): - fmpq_mat_init(self.val, - fmpz_mat_nrows((val).val), - fmpz_mat_ncols((val).val)) - fmpq_mat_set_fmpz_mat(self.val, (val).val) - elif isinstance(val, (list, tuple)): - m = len(val) - n = 0 - if m != 0: - if not isinstance(val[0], (list, tuple)): - raise TypeError("single input to fmpq_mat must be a list of lists") - n = len(val[0]) - for i from 1 <= i < m: - if len(val[i]) != n: - raise ValueError("input rows have different lengths") - fmpq_mat_init(self.val, m, n) - for i from 0 <= i < m: - row = val[i] - for j from 0 <= j < n: - x = fmpq(row[j]) - fmpq_set(fmpq_mat_entry(self.val, i, j), (x).val) - else: - raise TypeError("cannot create fmpq_mat from input of type %s" % type(val)) - elif len(args) == 2: - m, n = args - fmpq_mat_init(self.val, m, n) - elif len(args) == 3: - m, n, entries = args - fmpq_mat_init(self.val, m, n) - entries = list(entries) - if len(entries) != m*n: - raise ValueError("list of entries has the wrong length") - for i from 0 <= i < m: - for j from 0 <= j < n: - # XXX: slow - x = fmpq(entries[i*n + j]) - fmpq_set(fmpq_mat_entry(self.val, i, j), (x).val) - else: - raise TypeError("fmpq_mat: expected 1-3 arguments") - - def __bool__(self): - return not fmpq_mat_is_zero(self.val) - - def __richcmp__(s, t, int op): - cdef bint r - if op != 2 and op != 3: - raise TypeError("matrices cannot be ordered") - s = any_as_fmpq_mat(s) - if t is NotImplemented: - return s - t = any_as_fmpq_mat(t) - if t is NotImplemented: - return t - r = fmpq_mat_equal((s).val, (t).val) - if op == 3: - r = not r - return r - - cpdef long nrows(self): - return fmpq_mat_nrows(self.val) - - cpdef long ncols(self): - return fmpq_mat_ncols(self.val) - - def __getitem__(self, index): - cdef long i, j - cdef fmpq x - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - x = fmpq.__new__(fmpq) - fmpq_set(x.val, fmpq_mat_entry(self.val, i, j)) - return x - - def __setitem__(self, index, value): - cdef long i, j - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - c = fmpq(value) # XXX - fmpq_set(fmpq_mat_entry(self.val, i, j), (c).val) - - def det(self): - """ - Returns the determinant of *self* as an *fmpq*. - - >>> (fmpq_mat(2,2,[1,2,3,4]) / 5).det() - -2/25 - """ - cdef fmpq d - if not fmpq_mat_is_square(self.val): - raise ValueError("matrix must be square") - d = fmpq.__new__(fmpq) - fmpq_mat_det(d.val, self.val) - return d - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpq_mat t = fmpq_mat(self) - fmpq_mat_neg(t.val, t.val) # XXX - return t - - def __add__(s, t): - cdef fmpq_mat u - cdef fmpq_mat_struct *sval - cdef fmpq_mat_struct *tval - t = any_as_fmpq_mat(t) - if t is NotImplemented: - return t - sval = &(s).val[0] - tval = &(t).val[0] - if (fmpq_mat_nrows(sval) != fmpq_mat_nrows(tval) or - fmpq_mat_ncols(sval) != fmpq_mat_ncols(tval)): - raise ValueError("incompatible shapes for matrix addition") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(sval), fmpq_mat_ncols(sval)) - fmpq_mat_add(u.val, sval, tval) - return u - - def __sub__(s, t): - cdef fmpq_mat u - cdef fmpq_mat_struct *sval - cdef fmpq_mat_struct *tval - t = any_as_fmpq_mat(t) - if t is NotImplemented: - return t - sval = &(s).val[0] - tval = &(t).val[0] - if (fmpq_mat_nrows(sval) != fmpq_mat_nrows(tval) or - fmpq_mat_ncols(sval) != fmpq_mat_ncols(tval)): - raise ValueError("incompatible shapes for matrix subtraction") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(sval), fmpq_mat_ncols(sval)) - fmpq_mat_sub(u.val, sval, tval) - return u - - cdef __mul_fmpz(self, fmpz c): - cdef fmpq_mat u - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(self.val), fmpq_mat_ncols(self.val)) - fmpq_mat_scalar_mul_fmpz(u.val, self.val, c.val) - return u - - cdef __mul_fmpq(self, fmpq c): - cdef fmpq_mat u - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(self.val), fmpq_mat_ncols(self.val)) - fmpq_mat_scalar_mul_fmpz(u.val, self.val, fmpq_numref(c.val)) - fmpq_mat_scalar_div_fmpz(u.val, u.val, fmpq_denref(c.val)) - return u - - cdef __mul_fmpq_mat(self, fmpq_mat other): - cdef fmpq_mat u - if self.ncols() != other.nrows(): - raise ValueError("incompatible shapes for matrix multiplication") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(self.val), fmpq_mat_ncols(other.val)) - fmpq_mat_mul(u.val, self.val, other.val) - return u - - cdef __mul_fmpz_mat(self, fmpz_mat other): - cdef fmpq_mat u - if self.ncols() != other.nrows(): - raise ValueError("incompatible shapes for matrix multiplication") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(self.val), fmpz_mat_ncols(other.val)) - fmpq_mat_mul_fmpz_mat(u.val, self.val, other.val) - return u - - cdef __mul_r_fmpz_mat(self, fmpz_mat other): - cdef fmpq_mat u - if self.nrows() != other.ncols(): - raise ValueError("incompatible shapes for matrix multiplication") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpz_mat_nrows(other.val), fmpq_mat_ncols(self.val)) - fmpq_mat_mul_r_fmpz_mat(u.val, other.val, self.val) - return u - - def __mul__(s, t): - if typecheck(t, fmpq_mat): - return (s).__mul_fmpq_mat(t) - elif typecheck(t, fmpz_mat): - return (s).__mul_fmpz_mat(t) - else: - c = any_as_fmpz(t) - if c is not NotImplemented: - return (s).__mul_fmpz(c) - c = any_as_fmpq(t) - if c is not NotImplemented: - return (s).__mul_fmpq(c) - return NotImplemented - - def __rmul__(s, t): - if typecheck(t, fmpz_mat): - return (s).__mul_r_fmpz_mat(t) - else: - c = any_as_fmpz(t) - if c is not NotImplemented: - return (s).__mul_fmpz(c) - c = any_as_fmpq(t) - if c is not NotImplemented: - return (s).__mul_fmpq(c) - return NotImplemented - - @staticmethod - def _div_(fmpq_mat s, t): - t = any_as_fmpq(t) - if t is NotImplemented: - return t - return s * (1 / t) - - def __truediv__(s, t): - return fmpq_mat._div_(s, t) - - def __div__(s, t): - return fmpq_mat._div_(s, t) - - def inv(self): - """ - Returns the inverse matrix of *self*. - - >>> (fmpq_mat([[1,2],[3,4]]) / 5).inv() - [ -10, 5] - [15/2, -5/2] - >>> (fmpq_mat([[1,2],[3,6]]) / 5).inv() - Traceback (most recent call last): - ... - ZeroDivisionError: matrix is singular - """ - cdef fmpq_mat u - if not fmpq_mat_is_square(self.val): - raise ValueError("matrix must be square") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows(self.val), fmpq_mat_ncols(self.val)) - if not fmpq_mat_inv(u.val, self.val): - raise ZeroDivisionError("matrix is singular") - return u - - def transpose(self): - """ - Returns the transpose of *self*. - - >>> fmpq_mat(2,3,range(6)).transpose() - [0, 3] - [1, 4] - [2, 5] - """ - cdef fmpq_mat u - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_ncols(self.val), fmpq_mat_nrows(self.val)) - fmpq_mat_transpose(u.val, self.val) - return u - - def solve(self, other, algorithm=None): - """ - Given matrices *A* and *B* represented by *self* and *other*, - returns an *fmpq_mat* *X* such that `AX = B`, assuming that - *A* is square and invertible. - - Algorithm can *None* for a default choice, or "fflu" or "dixon" - (faster for large matrices). - - >>> A = fmpq_mat(2, 2, [1,4,8,3]) - >>> B = fmpq_mat(2, 3, range(6)) - >>> X = A.solve(B) - >>> X - [12/29, 13/29, 14/29] - [-3/29, 4/29, 11/29] - >>> A*X == B - True - >>> A.solve(B, algorithm='dixon') == X - True - >>> fmpq_mat(2, 2, [1,0,2,0]).solve(B) - Traceback (most recent call last): - ... - ZeroDivisionError: singular matrix in solve() - >>> A.solve(fmpq_mat(1, 2, [2,3])) - Traceback (most recent call last): - ... - ValueError: need a square system and compatible right hand side - - """ - cdef fmpq_mat u - cdef int result - t = any_as_fmpq_mat(other) - if t is NotImplemented: - raise TypeError("cannot convert input to fmpq_mat") - if (fmpq_mat_nrows(self.val) != fmpq_mat_ncols(self.val) or - fmpq_mat_nrows(self.val) != fmpq_mat_nrows((t).val)): - raise ValueError("need a square system and compatible right hand side") - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpq_mat_nrows((t).val), - fmpq_mat_ncols((t).val)) - if algorithm is None: - if fmpq_mat_nrows(self.val) < 25: - result = fmpq_mat_solve_fraction_free(u.val, self.val, (t).val) - else: - result = fmpq_mat_solve_dixon(u.val, self.val, (t).val) - elif algorithm == "fflu": - result = fmpq_mat_solve_fraction_free(u.val, self.val, (t).val) - elif algorithm == "dixon": - result = fmpq_mat_solve_dixon(u.val, self.val, (t).val) - else: - raise ValueError("unknown algorithm") - if not result: - raise ZeroDivisionError("singular matrix in solve()") - return u - - def rref(self, inplace=False): - """ - Computes the reduced row echelon form (rref) of *self*, - either returning a new copy or modifying self in-place. - Returns (*rref*, *rank*). - - >>> A = fmpq_mat(3,3,range(9)) - >>> A.rref() - ([1, 0, -1] - [0, 1, 2] - [0, 0, 0], 2) - >>> A.rref(inplace=True) - ([1, 0, -1] - [0, 1, 2] - [0, 0, 0], 2) - >>> A - [1, 0, -1] - [0, 1, 2] - [0, 0, 0] - - """ - if inplace: - res = self - else: - res = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init((res).val, fmpq_mat_nrows(self.val), fmpq_mat_ncols(self.val)) - rank = fmpq_mat_rref((res).val, self.val) - return res, rank - - def rank(self): - """ - Returns the rank of *self*. - - >>> from flint import fmpq_mat - >>> M = fmpq_mat([[1,2,3],[4,5,6],[7,8,9]]) - >>> M.rank() - 2 - """ - return self.rref()[1] - - @classmethod - def hilbert(cls, long n, long m): - """ - Returns the *n* by *m* truncated Hilbert matrix. - - >>> fmpq_mat.hilbert(2,3) - [ 1, 1/2, 1/3] - [1/2, 1/3, 1/4] - """ - cdef fmpq_mat u - u = fmpq_mat(n, m) - fmpq_mat_hilbert_matrix(u.val) - return u - - def numer_denom(self): - """ - Returns (*A*, *d*) where *A* is an *fmpz_mat* and *d* is an - *fmpz* representing the minimal denominator such that - *A* times *d* equals *self*. - - >>> A, d = fmpq_mat.hilbert(3,3).numer_denom() - >>> A - [60, 30, 20] - [30, 20, 15] - [20, 15, 12] - >>> d - 60 - """ - cdef fmpz_mat num - num = fmpz_mat(self.nrows(), self.ncols()) - den = fmpz() - fmpq_mat_get_fmpz_mat_matwise(num.val, den.val, self.val) - return num, den - - def charpoly(self): - """Returns the characteristic polynomial of *self* as an *fmpq_poly*. - - >>> from flint import fmpq_mat, fmpq - >>> A = fmpq_mat(3,3,[1,3,5,2,4,6,fmpq(2,3),2,4]) - >>> A - [ 1, 3, 5] - [ 2, 4, 6] - [2/3, 2, 4] - >>> A.charpoly() - x^3 + (-9)*x^2 + 8/3*x + 4/3 - """ - cdef fmpq_poly u - - if self.nrows() != self.ncols(): - raise ValueError("matrix must be square") - - u = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_init(u.val) - fmpq_mat_charpoly(u.val, self.val) - return u - - def minpoly(self): - """Returns the minimal polynomial of *self* as an *fmpq_poly*. - - >>> from flint import fmpq_mat, fmpq - >>> A = fmpq_mat([[2, 1, 0], [0, 2, 0], [0, 0, 2]]) - >>> A - [2, 1, 0] - [0, 2, 0] - [0, 0, 2] - >>> A.charpoly() - x^3 + (-6)*x^2 + 12*x + (-8) - >>> A.minpoly() - x^2 + (-4)*x + 4 - """ - cdef fmpq_poly u - - if self.nrows() != self.ncols(): - raise ValueError("matrix must be square") - - u = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_init(u.val) - fmpq_mat_minpoly(u.val, self.val) - return u - - def __pow__(self, n, z): - cdef fmpq_mat v - - if self.nrows() != self.ncols(): - raise ValueError("matrix must be square") - if z is not None: - raise TypeError("fmpq_mat does not support modular exponentiation") - - n = int(n) - if n == 0: - r = self.nrows() - v = fmpq_mat(r, r) - fmpq_mat_one(v.val) - return v - if n == 1: - return self - if n == 2: - return self * self - if n < 0: - return self.inv() ** (-n) - - v = self ** (n // 2) - v = v * v - if n % 2: - v *= self - return v diff --git a/src/flint/types/fmpq_mpoly.pxd b/src/flint/types/fmpq_mpoly.pxd deleted file mode 100644 index a89871f2..00000000 --- a/src/flint/types/fmpq_mpoly.pxd +++ /dev/null @@ -1,39 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mpoly -from flint.flint_base.flint_base cimport flint_mpoly_context - -from flint.flintlib.functions.fmpq_mpoly cimport ( - fmpq_mpoly_ctx_t, - fmpq_mpoly_t, - fmpq_mpoly_struct, - fmpq_mpoly_init, -) -from flint.flintlib.types.flint cimport slong - -from flint.types.fmpz_mpoly cimport fmpz_mpoly_ctx - -cdef inline init_fmpq_mpoly(fmpq_mpoly var, fmpq_mpoly_ctx ctx): - var.ctx = ctx - fmpq_mpoly_init(var.val, ctx.val) - var._init = True - -cdef inline create_fmpq_mpoly(fmpq_mpoly_ctx ctx): - cdef fmpq_mpoly var - var = fmpq_mpoly.__new__(fmpq_mpoly) - var.ctx = ctx - fmpq_mpoly_init(var.val, ctx.val) - var._init = True - return var - -cdef class fmpq_mpoly_ctx(flint_mpoly_context): - cdef fmpq_mpoly_ctx_t val - -cdef class fmpq_mpoly(flint_mpoly): - cdef fmpq_mpoly_t val - cdef fmpq_mpoly_ctx ctx - cdef bint _init - -cdef class fmpq_mpoly_vec: - cdef fmpq_mpoly_struct *val - cdef slong length - cdef fmpq_mpoly_ctx ctx - cdef fmpq_mpoly_struct **double_indirect diff --git a/src/flint/types/fmpq_mpoly.pyi b/src/flint/types/fmpq_mpoly.pyi deleted file mode 100644 index 6dec549b..00000000 --- a/src/flint/types/fmpq_mpoly.pyi +++ /dev/null @@ -1,124 +0,0 @@ -from typing import Iterable, Mapping, Any -from ..flint_base.flint_base import flint_mpoly, flint_mpoly_context, Ordering -from .fmpz import fmpz -from .fmpq import fmpq -from .fmpz_mpoly import fmpz_mpoly - - -_str = str -ifmpz = int | fmpz -ifmpq = int | fmpz | fmpq - - -class fmpq_mpoly_ctx(flint_mpoly_context[fmpq_mpoly, fmpq, ifmpq]): - @classmethod - def get(cls, - names: _str | Iterable[_str | tuple[_str, int]] | tuple[_str, int], - ordering: Ordering | _str = Ordering.lex - ) -> fmpq_mpoly_ctx: - ... - - def nvars(self) -> int: ... - def ordering(self) -> Ordering: ... - def gen(self, i: int, /) -> fmpq_mpoly: ... - def from_dict(self, d: Mapping[tuple[int, ...], ifmpq], /) -> fmpq_mpoly: ... - def constant(self, q: ifmpq, /) -> fmpq_mpoly: ... - def name(self, i: int, /) -> str: ... - def names(self) -> tuple[str, ...]: ... - def gens(self) -> tuple[fmpq_mpoly, ...]: ... - def variable_to_index(self, var: str, /) -> int: ... - def term( - self, coeff: ifmpq | None = None, exp_vec: Iterable[int] | None = None - ) -> fmpq_mpoly: ... - def drop_gens(self, gens: Iterable[str | int], /) -> fmpq_mpoly_ctx: ... - def append_gens(self, gens: Iterable[str | int], /) -> fmpq_mpoly_ctx: ... - def infer_generator_mapping( - self, ctx: flint_mpoly_context, / - ) -> dict[int, int]: ... - @classmethod - def from_context( - cls, - ctx: flint_mpoly_context[Any, Any, Any], - names: str | Iterable[str | tuple[str, int]] | tuple[str, int] | None = None, - ordering: Ordering | str = Ordering.lex, - ) -> fmpq_mpoly_ctx: ... - -class fmpq_mpoly(flint_mpoly[fmpq_mpoly_ctx, fmpq, ifmpq]): - def __init__(self, - val: fmpq_mpoly | fmpz_mpoly | ifmpq | Mapping[tuple[int, ...], ifmpq] | _str = 0, - ctx: fmpq_mpoly_ctx | None = None - ) -> None: ... - - def str(self) -> _str: ... - def repr(self) -> _str: ... - - def context(self) -> fmpq_mpoly_ctx: ... - - def degrees(self) -> tuple[int, ...]: ... - def total_degree(self) -> int: ... - - def is_one(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_constant(self) -> bool: ... - - def __len__(self) -> int: ... - def coefficient(self, i: int) -> fmpq: ... - def monomial(self, i: int) -> tuple[int, ...]: ... - - def monoms(self) -> list[tuple[int, ...]]: ... - def coeffs(self) -> list[fmpq]: ... - def __getitem__(self, index: tuple[int, ...]) -> fmpq: ... - def __setitem__(self, index: tuple[int, ...], coeff: ifmpq) -> None: ... - - def subs(self, mapping: Mapping[_str | int, ifmpq]) -> fmpq_mpoly: ... - def compose(self, *args: fmpq_mpoly, ctx: fmpq_mpoly_ctx | None = None) -> fmpq_mpoly: ... - - def __call__(self, *args: ifmpq) -> fmpq: ... - - def __pos__(self) -> fmpq_mpoly: ... - def __neg__(self) -> fmpq_mpoly: ... - def __add__(self, other: fmpq_mpoly | ifmpq) -> fmpq_mpoly: ... - def __radd__(self, other: ifmpq) -> fmpq_mpoly: ... - def __sub__(self, other: fmpq_mpoly | ifmpq) -> fmpq_mpoly: ... - def __rsub__(self, other: ifmpq) -> fmpq_mpoly: ... - def __mul__(self, other: fmpq_mpoly | ifmpq) -> fmpq_mpoly: ... - def __rmul__(self, other: ifmpq) -> fmpq_mpoly: ... - def __truediv__(self, other: fmpq_mpoly | ifmpq) -> fmpq_mpoly: ... - def __rtruediv__(self, other: ifmpq) -> fmpq_mpoly: ... - def __floordiv__(self, other: fmpq_mpoly | ifmpq) -> fmpq_mpoly: ... - def __rfloordiv__(self, other: ifmpq) -> fmpq_mpoly: ... - def __mod__(self, other: fmpq_mpoly | ifmpq) -> fmpq_mpoly: ... - def __rmod__(self, other: ifmpq) -> fmpq_mpoly: ... - def __divmod__(self, other: fmpq_mpoly | ifmpq) -> tuple[fmpq_mpoly, fmpq_mpoly]: ... - def __rdivmod__(self, other: ifmpq) -> tuple[fmpq_mpoly, fmpq_mpoly]: ... - def __pow__(self, other: ifmpq) -> fmpq_mpoly: ... - def __rpow__(self, other: ifmpq) -> fmpq_mpoly: ... - - def iadd(self, other: fmpq_mpoly | ifmpq) -> None: ... - def isub(self, other: fmpq_mpoly | ifmpq) -> None: ... - def imul(self, other: fmpq_mpoly | ifmpq) -> None: ... - - def gcd(self, other: fmpq_mpoly) -> fmpq_mpoly: ... - def xgcd(self, other: fmpq_mpoly, /) -> fmpq: ... - def term_content(self) -> fmpq_mpoly: ... - - def factor(self) -> tuple[fmpq, list[tuple[fmpq_mpoly, int]]]: ... - def factor_squarefree(self) -> tuple[fmpq, list[tuple[fmpq_mpoly, int]]]: ... - - def sqrt(self, assume_perfect_square: bool = False) -> fmpq_mpoly: ... - - def resultant(self, other: fmpq_mpoly, var: _str | int) -> fmpq_mpoly: ... - def discriminant(self, var: _str | int) -> fmpq_mpoly: ... - - def deflation(self) -> tuple[fmpq_mpoly, list[int]]: ... - def inflate(self, N: list[int]) -> fmpq_mpoly: ... - def deflate(self, N: list[int]) -> fmpq_mpoly: ... - def deflation_monom(self) -> tuple[fmpq_mpoly, list[int], fmpq_mpoly]: ... - def deflation_index(self) -> tuple[list[int], list[int]]: ... - - def derivative(self, var: _str | int) -> fmpq_mpoly: ... - def integral(self, var: _str | int) -> fmpq_mpoly: ... - - -class fmpq_mpoly_vec: - ... diff --git a/src/flint/types/fmpq_mpoly.pyx b/src/flint/types/fmpq_mpoly.pyx deleted file mode 100644 index 099189af..00000000 --- a/src/flint/types/fmpq_mpoly.pyx +++ /dev/null @@ -1,1255 +0,0 @@ -cimport cython - -from flint.flintlib.types.flint cimport ulong - -from flint.flint_base.flint_base cimport ( - flint_mpoly, - flint_mpoly_context, - ordering_py_to_c, - ordering_c_to_py, -) - -from flint.utils.typecheck cimport typecheck -from flint.utils.flint_exceptions import DomainError, IncompatibleContextError - -from flint.types.fmpq cimport fmpq, any_as_fmpq -from flint.types.fmpz_vec cimport fmpz_vec -from flint.types.fmpq_vec cimport fmpq_vec - -from flint.types.fmpz cimport fmpz, any_as_fmpz -from flint.types.fmpz_mpoly cimport fmpz_mpoly - -from flint.flintlib.functions.fmpq cimport fmpq_set, fmpq_one -from flint.flintlib.functions.fmpq_mpoly cimport ( - fmpq_mpoly_add, - fmpq_mpoly_add_fmpq, - fmpq_mpoly_clear, - fmpq_mpoly_compose_fmpq_mpoly, - fmpq_mpoly_compose_fmpq_mpoly_gen, - fmpq_mpoly_ctx_init, - fmpq_mpoly_degrees_fmpz, - fmpq_mpoly_derivative, - fmpq_mpoly_discriminant, - fmpq_mpoly_div, - fmpq_mpoly_divides, - fmpq_mpoly_divrem, - fmpq_mpoly_equal, - fmpq_mpoly_equal_fmpq, - fmpq_mpoly_equal_fmpz, - fmpq_mpoly_evaluate_all_fmpq, - fmpq_mpoly_evaluate_one_fmpq, - fmpq_mpoly_gcd, - fmpq_mpoly_gen, - fmpq_mpoly_get_coeff_fmpq_fmpz, - fmpq_mpoly_get_str_pretty, - fmpq_mpoly_get_term_coeff_fmpq, - fmpq_mpoly_get_term_exp_fmpz, - fmpq_mpoly_integral, - fmpq_mpoly_is_one, - fmpq_mpoly_is_zero, - fmpq_mpoly_length, - fmpq_mpoly_mul, - fmpq_mpoly_neg, - fmpq_mpoly_pow_fmpz, - fmpq_mpoly_push_term_fmpq_ffmpz, - fmpq_mpoly_push_term_ui_ffmpz, - fmpq_mpoly_reduce, - fmpq_mpoly_resultant, - fmpq_mpoly_scalar_div_fmpq, - fmpq_mpoly_scalar_mul_fmpq, - fmpq_mpoly_set, - fmpq_mpoly_set_coeff_fmpq_fmpz, - fmpq_mpoly_set_fmpq, - fmpq_mpoly_set_str_pretty, - fmpq_mpoly_sort_terms, - fmpq_mpoly_sqrt, - fmpq_mpoly_sub, - fmpq_mpoly_sub_fmpq, - fmpq_mpoly_term_content, - fmpq_mpoly_total_degree_fmpz, -) -from flint.flintlib.functions.fmpq_mpoly_factor cimport ( - fmpq_mpoly_factor, - fmpq_mpoly_factor_clear, - fmpq_mpoly_factor_init, - fmpq_mpoly_factor_squarefree, - fmpq_mpoly_factor_t, -) - -from flint.flintlib.functions.fmpz cimport fmpz_init_set -from flint.flintlib.functions.fmpz_mpoly cimport ( - fmpz_mpoly_set, - fmpz_mpoly_deflate, - fmpz_mpoly_deflation, - fmpz_mpoly_inflate, -) - -from cpython.object cimport Py_EQ, Py_NE -cimport libc.stdlib - -cdef dict _fmpq_mpoly_ctx_cache = {} - - -cdef class fmpq_mpoly_ctx(flint_mpoly_context): - """ - A class for storing the polynomial context - - :param names: A tuple containing the names of the variables of the ring. - :param ordering: The term order for the ring. - - Do not construct one of these directly, use ``fmpq_mpoly_ctx.get``. - """ - - _ctx_cache = _fmpq_mpoly_ctx_cache - - @classmethod - def _new_(cls, names, ordering): - cdef fmpq_mpoly_ctx self = cls.__new__(cls) - super()._new_(self, names) - fmpq_mpoly_ctx_init(self.val, len(names), ordering_py_to_c(ordering)) - - return self - - def _any_as_scalar(self, other): - if isinstance(other, int): - return any_as_fmpq(other) - elif typecheck(other, fmpz): - return any_as_fmpq(other) - elif typecheck(other, fmpq): - res = fmpq.__new__(fmpq) - fmpq_set((res).val, (other).val) - return res - else: - return NotImplemented - - def _scalar_as_mpoly(self, other: fmpq): - # non-fmpq scalars should first be converted via self._any_as_scalar - return self.constant(other) - - def nvars(self): - """ - Return the number of variables in the context - - >>> ctx = fmpq_mpoly_ctx.get(('x', 4), 'lex') - >>> ctx.nvars() - 4 - """ - return self.val.zctx.minfo.nvars - - def ordering(self): - """ - Return the term order of the context object. - - >>> ctx = fmpq_mpoly_ctx.get(('w', 4), 'deglex') - >>> ctx.ordering() - - """ - return ordering_c_to_py(self.val.zctx.minfo.ord) - - def gen(self, slong i): - """ - Return the ``i`` th generator of the polynomial ring - - >>> ctx = fmpq_mpoly_ctx.get(('z', 3), 'degrevlex') - >>> ctx.gen(1) - z1 - """ - cdef fmpq_mpoly res - if not 0 <= i < self.val.zctx.minfo.nvars: - raise IndexError("generator index out of range") - res = create_fmpq_mpoly(self) - fmpq_mpoly_gen(res.val, i, res.ctx.val) - return res - - def constant(self, z): - """ - Create a constant polynomial in this context - """ - cdef fmpq_mpoly res - z = any_as_fmpq(z) - if z is NotImplemented: - raise TypeError("cannot coerce argument to fmpq") - res = create_fmpq_mpoly(self) - fmpq_mpoly_set_fmpq(res.val, (z).val, res.ctx.val) - return res - - def from_dict(self, d): - """ - Create a fmpq_mpoly from a dictionary. - - The dictionary's keys are tuples of ints (or anything that implicitly converts - to fmpz) representing exponents, and corresponding coefficient values of fmpq. - - >>> 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 - """ - cdef: - fmpz_vec exp_vec - slong nvars = self.nvars() - fmpq_mpoly res - - if not isinstance(d, dict): - raise ValueError("expected a dictionary") - - res = create_fmpq_mpoly(self) - - for k, v in d.items(): - o = any_as_fmpq(v) - if o is NotImplemented: - raise TypeError(f"cannot coerce coefficient '{v}' to fmpq") - elif len(k) != nvars: - raise ValueError(f"expected {nvars} exponents, got {len(k)}") - - exp_vec = fmpz_vec(k) - - if o: - fmpq_mpoly_push_term_fmpq_ffmpz(res.val, (o).val, exp_vec.val, self.val) - - fmpq_mpoly_sort_terms(res.val, self.val) - fmpq_mpoly_reduce(res.val, self.val) - return res - - -cdef class fmpq_mpoly(flint_mpoly): - """ - The *fmpq_mpoly* type represents sparse multivariate polynomials over - the rationals. - """ - - def __cinit__(self): - self._init = False - - def __dealloc__(self): - if self._init: - fmpq_mpoly_clear(self.val, self.ctx.val) - self._init = False - - def __init__(self, val=0, ctx=None): - if typecheck(val, fmpq_mpoly): - if ctx is None or ctx == (val).ctx: - init_fmpq_mpoly(self, (val).ctx) - fmpq_mpoly_set(self.val, (val).val, self.ctx.val) - else: - raise IncompatibleContextError(f"{ctx} is not {(val).ctx}") - elif typecheck(val, fmpz_mpoly): - if ctx is None: - ctx = fmpq_mpoly_ctx.from_context((val).ctx) - elif not typecheck(ctx, fmpq_mpoly_ctx) and not typecheck(ctx, fmpz_mpoly_ctx): - raise TypeError(f"{ctx} is not a fmpq_mpoly_ctx or fmpz_mpoly_ctx") - elif ctx.nvars() != val.context().nvars(): - raise ValueError( - f"Provided context ('{ctx}') and provided fmpz_mpoly ('{val}') don't share the same number of " - "variables" - ) - init_fmpq_mpoly(self, ctx) - fmpz_mpoly_set(self.val.zpoly, (val).val, ( val).ctx.val) - fmpq_one(self.val.content) - fmpq_mpoly_reduce(self.val, self.ctx.val) - elif isinstance(val, dict): - if ctx is None: - raise ValueError("a context is required to create a fmpq_mpoly from a dict") - x = ctx.from_dict(val) - # XXX: this copy is silly, have a ctx function that assigns an fmpz_mpoly_t - init_fmpq_mpoly(self, ctx) - fmpq_mpoly_set(self.val, (x).val, self.ctx.val) - elif isinstance(val, str): - if ctx is None: - raise ValueError("cannot parse a polynomial without context") - val = val.encode("ascii") - init_fmpq_mpoly(self, ctx) - if fmpq_mpoly_set_str_pretty(self.val, val, self.ctx.c_names, self.ctx.val) == -1: - raise ValueError("unable to parse fmpq_mpoly from string") - fmpq_mpoly_sort_terms(self.val, self.ctx.val) - else: - v = any_as_fmpq(val) - if v is NotImplemented: - raise TypeError("cannot create fmpz_mpoly from type %s" % type(val)) - if ctx is None: - raise ValueError("need context to convert fmpz to fmpq_mpoly") - init_fmpq_mpoly(self, ctx) - fmpq_mpoly_set_fmpq(self.val, (v).val, self.ctx.val) - - def __bool__(self): - return not fmpq_mpoly_is_zero(self.val, self.ctx.val) - - def is_zero(self): - return fmpq_mpoly_is_zero(self.val, self.ctx.val) - - def is_one(self): - return fmpq_mpoly_is_one(self.val, self.ctx.val) - - def is_constant(self): - """ - Returns True if this is a constant polynomial. - - >>> R = fmpq_mpoly_ctx.get(['x', 'y']) - >>> x, y = R.gens() - >>> x.is_constant() - False - >>> (0*x + 1).is_constant() - True - """ - return self.total_degree() <= 0 - - def __richcmp__(self, other, int op): - if not (op == Py_EQ or op == Py_NE): - return NotImplemented - elif other is None: - return op == Py_NE - elif typecheck(self, fmpq_mpoly) and typecheck(other, fmpq_mpoly): - if (self).ctx is (other).ctx: - return (op == Py_NE) ^ fmpq_mpoly_equal(self.val, (other).val, self.ctx.val) - else: - return op == Py_NE - elif typecheck(other, fmpq): - return (op == Py_NE) ^ fmpq_mpoly_equal_fmpq(self.val, (other).val, self.ctx.val) - elif typecheck(other, fmpz): - return (op == Py_NE) ^ fmpq_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - elif isinstance(other, int): - other = any_as_fmpz(other) - if other is NotImplemented: - return NotImplemented - return (op == Py_NE) ^ fmpq_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - else: - return NotImplemented - - def __len__(self): - return fmpq_mpoly_length(self.val, self.ctx.val) - - def __getitem__(self, x): - """ - Return the coefficient of the term with the exponent vector ``x``. - Always returns a value, missing keys will return ``0``. - Negative exponents are made positive. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] - 3 - - """ - cdef: - slong nvars = self.ctx.nvars() - - if not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - res = fmpq() - exp_vec = fmpz_vec(x, double_indirect=True) - fmpq_mpoly_get_coeff_fmpq_fmpz((res).val, self.val, exp_vec.double_indirect, self.ctx.val) - return res - - def __setitem__(self, x, y): - """ - Set the coefficient of the term with the exponent vector ``x`` to ``y``. - Will always set a value, missing keys will create a new term. - Negative exponents are made positive. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] = 20 - >>> p - 20*x0*x1 + 2*x1 - - """ - cdef: - slong nvars = self.ctx.nvars() - - coeff = any_as_fmpq(y) - if coeff is NotImplemented: - raise TypeError("provided coefficient not coercible to fmpq") - elif not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - exp_vec = fmpz_vec(x, double_indirect=True) - fmpq_mpoly_set_coeff_fmpq_fmpz(self.val, (coeff).val, exp_vec.double_indirect, self.ctx.val) - - def __neg__(self): - cdef fmpq_mpoly res - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_neg(res.val, (self).val, res.ctx.val) - return res - - cdef _add_scalar_(self, arg): - cdef fmpq_mpoly res - cdef fmpq other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_add_fmpq(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _add_mpoly_(self, arg): - cdef fmpq_mpoly res, other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_add(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _sub_scalar_(self, arg): - cdef fmpq_mpoly res - cdef fmpq other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_sub_fmpq(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _sub_mpoly_(self, arg): - cdef fmpq_mpoly res, other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_sub(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _mul_scalar_(self, arg): - cdef fmpq_mpoly res - cdef fmpq other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_scalar_mul_fmpq(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _mul_mpoly_(self, arg): - cdef fmpq_mpoly res, other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_mul(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _pow_(self, arg): - cdef fmpq_mpoly res - cdef fmpz other = arg - res = create_fmpq_mpoly(self.ctx) - if fmpq_mpoly_pow_fmpz(res.val, self.val, other.val, res.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - cdef _divmod_mpoly_(self, arg): - cdef fmpq_mpoly quotient, remainder, other = arg - quotient = create_fmpq_mpoly(self.ctx) - remainder = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return (quotient, remainder) - - cdef _floordiv_mpoly_(self, arg): - cdef fmpq_mpoly quotient, other = arg - quotient = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_div(quotient.val, self.val, other.val, self.ctx.val) - return quotient - - cdef _truediv_scalar_(self, arg): - cdef fmpq_mpoly quotient - cdef fmpq other = arg - quotient = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_scalar_div_fmpq(quotient.val, self.val, other.val, self.ctx.val) - return quotient - - cdef _divexact_scalar_(self, arg): - return self._truediv_scalar_(arg) - - cdef _truediv_mpoly_(self, arg): - cdef fmpq_mpoly quotient, other = arg - quotient = create_fmpq_mpoly(self.ctx) - if fmpq_mpoly_divides(quotient.val, self.val, other.val, self.ctx.val): - return quotient - else: - raise DomainError("fmpq_mpoly division is not exact") - - cdef _mod_mpoly_(self, arg): - cdef fmpq_mpoly quotient, remainder, other = arg - quotient = create_fmpq_mpoly(self.ctx) - remainder = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return remainder - - cdef _rsub_scalar_(self, arg): - cdef fmpq_mpoly res - cdef fmpq other = arg - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_sub_fmpq(res.val, self.val, other.val, self.ctx.val) - fmpq_mpoly_neg(res.val, res.val, res.ctx.val) - return res - - cdef _rsub_mpoly_(self, arg): - return (arg)._sub_mpoly_(self) - - cdef _rdivmod_mpoly_(self, arg): - return (arg)._divmod_mpoly_(self) - - cdef _rfloordiv_mpoly_(self, arg): - return (arg)._floordiv_mpoly_(self) - - cdef _rtruediv_mpoly_(self, arg): - return (arg)._truediv_mpoly_(self) - - cdef _rmod_mpoly_(self, arg): - return (arg)._mod_mpoly_(self) - - cdef _iadd_scalar_(self, arg): - cdef fmpq other = arg - fmpq_mpoly_add_fmpq(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_scalar_(self, arg): - cdef fmpq other = arg - fmpq_mpoly_sub_fmpq(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_scalar_(self, arg): - cdef fmpq other = arg - fmpq_mpoly_scalar_mul_fmpq(self.val, self.val, other.val, self.ctx.val) - - cdef _iadd_mpoly_(self, arg): - cdef fmpq_mpoly other = arg - fmpq_mpoly_add(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_mpoly_(self, arg): - cdef fmpq_mpoly other = arg - fmpq_mpoly_sub(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_mpoly_(self, arg): - cdef fmpq_mpoly other = arg - fmpq_mpoly_mul(self.val, self.val, other.val, self.ctx.val) - - def __call__(self, *args) -> fmpq: - cdef: - fmpq_vec V - fmpq vres - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs != nvars: - raise ValueError("number of generators does not match number of arguments") - - V = fmpq_vec(args, double_indirect=True) - vres = fmpq.__new__(fmpq) - if fmpq_mpoly_evaluate_all_fmpq(vres.val, self.val, V.double_indirect, self.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return vres - - def monoms(self): - """ - Return the exponent vectors of each term as a tuple of fmpz. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), '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)] - - """ - cdef: - slong i, nvars = self.ctx.nvars() - fmpz_vec vec = fmpz_vec(nvars, double_indirect=True) - - res = [] - for i in range(len(self)): - fmpq_mpoly_get_term_exp_fmpz(vec.double_indirect, self.val, i, self.ctx.val) - res.append(tuple(vec)) - - return res - - def coeffs(self): - """ - Return the coefficients of each term as a fmpq. - - >>> ctx = fmpq_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] - - """ - cdef: - fmpq coeff - slong i - - res = [] - for i in range(len(self)): - coeff = fmpq.__new__(fmpq) - fmpq_mpoly_get_term_coeff_fmpq(coeff.val, self.val, i, self.ctx.val) - res.append(coeff) - - return res - - def subs(self, dict_args) -> fmpq_mpoly: - """ - Partial evaluate this polynomial with select constants. Keys must be generator names or generator indices, - all values must be fmpq. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(0, 0): 1, (1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> f.subs({"x1": 0}) - 2*x0 + 1 - - """ - cdef: - fmpq_mpoly res - slong i - - args = tuple((self.ctx.variable_to_index(k), any_as_fmpq(v)) for k, v in dict_args.items()) - for _, v in args: - if v is NotImplemented: - raise TypeError(f"cannot coerce argument ('{v}') to fmpq") - - # Partial application with args in Q. We evaluate the polynomial one variable at a time - res = create_fmpq_mpoly(self.ctx) - - fmpq_mpoly_set(res.val, self.val, self.ctx.val) - for i, arg in args: - if fmpq_mpoly_evaluate_one_fmpq(res.val, res.val, i, (arg).val, self.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - def compose(self, *args, ctx=None) -> fmpq_mpoly: - """ - Compose this polynomial with other fmpq_mpolys. All arguments must share the same context, it may different - from this polynomials context. - - >>> ctx = fmpq_mpoly_ctx.get(('x',), 'lex') - >>> ctx1 = fmpq_mpoly_ctx.get(('y', 2), '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 - - """ - cdef: - fmpq_mpoly res - fmpq_mpoly_ctx res_ctx - fmpq_mpoly_vec C - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs < nvars: - raise ValueError("not enough arguments provided") - elif nargs > nvars: - raise ValueError("more arguments provided than variables") - elif self.ctx.nvars() == 0 and ctx is None: - raise ValueError("a context must be provided when composing a polynomial with no generators") - elif not all(typecheck(arg, fmpq_mpoly) for arg in args): - raise TypeError("all arguments must be fmpq_mpolys") - - if ctx is None: - res_ctx = ( args[0]).ctx - elif typecheck(ctx, fmpq_mpoly_ctx): - res_ctx = ctx - else: - raise TypeError(f"provided context ({ctx}) is not a fmpq_mpoly_ctx") - - if not all(( arg).ctx is res_ctx for arg in args): - raise IncompatibleContextError( - "all arguments must share the " + ("same" if ctx is not None else "provided") + " context" - ) - - C = fmpq_mpoly_vec(args, res_ctx, double_indirect=True) - res = create_fmpq_mpoly(res_ctx) - if fmpq_mpoly_compose_fmpq_mpoly(res.val, self.val, C.double_indirect, self.ctx.val, res_ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - def context(self): - """ - Return the context object for this polynomials. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2}) - >>> ctx is p.context() - True - """ - return self.ctx - - def coefficient(self, slong i): - """ - Return the coefficient at index ``i``. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.coefficient(1) - 2 - """ - cdef fmpq v - if not 0 <= i < fmpq_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - else: - v = fmpq.__new__(fmpq) - fmpq_mpoly_get_term_coeff_fmpq(v.val, self.val, i, self.ctx.val) - return v - - def monomial(self, slong i): - """ - Return the exponent vector at index ``i`` as a tuple. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.monomial(1) - (0, 1) - """ - cdef: - slong nvars = self.ctx.nvars() - - if not 0 <= i < fmpq_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - res = fmpz_vec(nvars, double_indirect=True) - fmpq_mpoly_get_term_exp_fmpz(res.double_indirect, self.val, i, self.ctx.val) - return tuple(res) - - def degrees(self): - """ - Return a dictionary of variable name to degree. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 4), 'lex') - >>> p = sum(x**i for i, x in enumerate(ctx.gens())) - >>> p - x1 + x2^2 + x3^3 + 1 - >>> p.degrees() - (0, 1, 2, 3) - """ - cdef: - slong nvars = self.ctx.nvars() - - res = fmpz_vec(nvars, double_indirect=True) - fmpq_mpoly_degrees_fmpz(res.double_indirect, self.val, self.ctx.val) - return tuple(res) - - def total_degree(self): - """ - Return the total degree. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 4), 'lex') - >>> p = ctx.from_dict({(1, 0, 0, 0): 1, (0, 2, 0, 0): 2, (0, 0, 3, 0): 3}) - >>> p.total_degree() - 3 - """ - cdef fmpz res = fmpz() - fmpq_mpoly_total_degree_fmpz(( res).val, self.val, self.ctx.val) - return res - - def leading_coefficient(self): - """ - Leading coefficient in the monomial ordering. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), '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 - - """ - if fmpq_mpoly_is_zero(self.val, self.ctx.val): - return fmpq(0) - else: - return self.coefficient(0) - - def repr(self): - return f"{self.ctx}.from_dict({self.to_dict()})" - - def str(self): - cdef bytes s = fmpq_mpoly_get_str_pretty(self.val, self.ctx.c_names, self.ctx.val) - # res = s.decode().replace("+", " + ").replace("-", " - ") - res = s.decode() - if res.startswith("- "): - res = "-" + res[3:] - return res - - def gcd(self, other): - """ - Return the gcd of self and other. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> g = ctx.from_dict({(0, 1): 2, (1, 0): 2}) - >>> (f * g).gcd(f) - x0*x1 + 1/4 - - """ - cdef fmpq_mpoly res - if not typecheck(other, fmpq_mpoly): - raise TypeError("argument must be a fmpq_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_gcd(res.val, (self).val, (other).val, res.ctx.val) - return res - - def term_content(self): - """ - Return the GCD of the terms of ``self``. If ``self`` is zero, then the result will - be zero, otherwise it will be a monomial with positive coefficient. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = 3 * x0**2 * x1 + 6 * x0 * x1 - >>> f.term_content() - x0*x1 - """ - cdef fmpq_mpoly res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_term_content(res.val, self.val, self.ctx.val) - return res - - def resultant(self, other, var): - """ - Return the resultant of ``self`` and ``other`` with respect to variable ``var``. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = x0**2 * x1 + x0 * x1 - >>> g = x0 + x1 - >>> f.resultant(g, 'x1') - x0^3 + x0^2 - """ - cdef: - fmpq_mpoly res - slong i - - if not typecheck(other, fmpq_mpoly): - raise TypeError("argument must be a fmpq_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - - i = self.ctx.variable_to_index(var) - res = create_fmpq_mpoly(self.ctx) - if not fmpq_mpoly_resultant(res.val, self.val, (other).val, i, self.ctx.val): - raise RuntimeError(f"failed to compute resultant with respect to {var}") - return res - - def discriminant(self, var): - """ - Return the discriminant of ``self`` with respect to variable ``var``. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = (x0 + x1)**2 + 1 - >>> f.discriminant('x1') - -4 - - """ - cdef: - fmpq_mpoly res - slong i - - i = self.ctx.variable_to_index(var) - res = create_fmpq_mpoly(self.ctx) - if not fmpq_mpoly_discriminant(res.val, self.val, i, self.ctx.val): - raise RuntimeError(f"failed to compute discriminant with respect to {var}") - return res - - def sqrt(self): - """ - Return the square root of self. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> (f * f).sqrt() - 4*x0*x1 + 1 - """ - cdef fmpq_mpoly res - res = create_fmpq_mpoly(self.ctx) - - if fmpq_mpoly_sqrt(res.val, self.val, self.ctx.val): - return res - else: - raise DomainError("polynomial is not a perfect square") - - def factor(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = fmpq_mpoly - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y', 'z'), 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*z + 3*x + 3*z + 3", ctx) - >>> (p1 * p2).factor() - (6, [(z + 1, 1), (x + 1, 1), (x + 2, 1)]) - >>> (p2 * p1 * p2).factor() - (18, [(x + 2, 1), (z + 1, 2), (x + 1, 2)]) - """ - cdef: - fmpq_mpoly_factor_t fac - fmpq_mpoly u - - fmpq_mpoly_factor_init(fac, self.ctx.val) - if not fmpq_mpoly_factor(fac, self.val, self.ctx.val): - raise RuntimeError("factorisation failed") - res = [0] * fac.num - - for i in range(fac.num): - u = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_init_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - c = fmpq.__new__(fmpq) - fmpq_set((c).val, fac.constant) - fmpq_mpoly_factor_clear(fac, self.ctx.val) - - res.sort(key=_fmpq_mpoly_sort_key) - - return c, res - - def factor_squarefree(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = fmpq_mpoly - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y', 'z'), 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*y + 3*x + 3*y + 3", ctx) - >>> (p1 * p2).factor_squarefree() - (6, [(y + 1, 1), (x^2 + 3*x + 2, 1)]) - >>> (p1 * p2 * p1).factor_squarefree() - (12, [(y + 1, 1), (x + 1, 1), (x + 2, 2)]) - """ - cdef: - fmpq_mpoly_factor_t fac - fmpq_mpoly u - - fmpq_mpoly_factor_init(fac, self.ctx.val) - fmpq_mpoly_factor_squarefree(fac, self.val, self.ctx.val) - res = [0] * fac.num - - for i in range(fac.num): - u = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_init(u.val, u.ctx.val) - fmpq_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_init_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - c = fmpq.__new__(fmpq) - fmpq_set((c).val, fac.constant) - fmpq_mpoly_factor_clear(fac, self.ctx.val) - return c, res - - def derivative(self, var): - """ - Return the derivative of this polynomial with respect to the provided variable. - The argument can either be the variable as a string, or the index of the - variable in the context. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 3): 2, (2, 1): 3}) - >>> p - 3*x0^2*x1 + 2*x1^3 - >>> p.derivative("x0") - 6*x0*x1 - >>> p.derivative(1) - 3*x0^2 + 6*x1^2 - - """ - cdef: - fmpq_mpoly res - slong i = self.ctx.variable_to_index(var) - - res = create_fmpq_mpoly(self.ctx) - - fmpq_mpoly_derivative(res.val, self.val, i, self.ctx.val) - return res - - def integral(self, var): - """ - Return the integral of this polynomial with respect to the provided variable The argument can either be the - variable as a string, or the index of the variable in the context. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 3): 2, (2, 1): 3}) - >>> p - 3*x0^2*x1 + 2*x1^3 - >>> p.integral("x0") - x0^3*x1 + 2*x0*x1^3 - >>> p.integral(1) - 3/2*x0^2*x1^2 + 1/2*x1^4 - - """ - cdef: - fmpq_mpoly res - slong i = self.ctx.variable_to_index(var) - - res = create_fmpq_mpoly(self.ctx) - - fmpq_mpoly_integral(res.val, self.val, i, self.ctx.val) - return res - - def inflate(self, N: list[int]) -> fmpq_mpoly: - """ - Compute the inflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^N)``. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x + y + 1 - >>> f.inflate([2, 3]) - x^2 + y^3 + 1 - """ - - cdef nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - elif any(n < 0 for n in N): - raise ValueError("all inflate strides must be non-negative") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - fmpq_mpoly res = create_fmpq_mpoly(self.ctx) - - fmpz_mpoly_inflate(res.val.zpoly, self.val.zpoly, shift.val, stride.val, self.ctx.val.zctx) - fmpq_set(res.val.content, self.val.content) - return res - - def deflate(self, N: list[int]) -> fmpq_mpoly: - """ - Compute the deflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^(1/N))``. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> f.deflate([2, 3]) - x + y + 1 - """ - cdef slong nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - fmpq_mpoly res = create_fmpq_mpoly(self.ctx) - - fmpz_mpoly_deflate(res.val.zpoly, self.val.zpoly, shift.val, stride.val, self.ctx.val.zctx) - fmpq_set(res.val.content, self.val.content) - return res - - def deflation(self) -> tuple[fmpq_mpoly, list[int]]: - """ - Compute the deflation of ``self``, that is ``p(X^(1/N))`` for maximal N. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**2 * y**2 + x * y**2 - >>> q, N = f.deflation() - >>> q, N - (x^2*y + x*y, [1, 2]) - >>> q.inflate(N) == f - True - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - fmpq_mpoly res = create_fmpq_mpoly(self.ctx) - - fmpz_mpoly_deflation(shift.val, stride.val, self.val.zpoly, self.ctx.val.zctx) - - for i in range(nvars): - stride[i] = shift[i].gcd(stride[i]) - shift[i] = 0 - - fmpz_mpoly_deflate(res.val.zpoly, self.val.zpoly, shift.val, stride.val, self.ctx.val.zctx) - fmpq_set(res.val.content, self.val.content) - - return res, list(stride) - - def deflation_monom(self) -> tuple[fmpq_mpoly, list[int], fmpq_mpoly]: - """ - Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N)) - = m * q(X^N)`` for maximal N. The returned monomial allows the undo-ing of the - deflation. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> fd, N, m = f.deflation_monom() - >>> fd, N, m - (x + y + 1, [2, 3], x*y) - >>> m * fd.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpq_mpoly res = create_fmpq_mpoly(self.ctx) - fmpq_mpoly monom = create_fmpq_mpoly(self.ctx) - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - fmpz_mpoly_deflation(shift.val, stride.val, self.val.zpoly, self.ctx.val.zctx) - fmpq_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val) - fmpz_mpoly_deflate(res.val.zpoly, self.val.zpoly, shift.val, stride.val, self.ctx.val.zctx) - fmpq_set(res.val.content, self.val.content) - - return res, list(stride), monom - - def deflation_index(self) -> tuple[list[int], list[int]]: - """ - Compute the exponent vectors ``N`` and ``I`` such that ``p(X^(1/N)) = X^I * - q(X^N)`` for maximal N. Importantly the deflation itself is not computed - here. The returned exponent vector ``I`` is the shift that was applied to the - exponents. It is the exponent vector of the monomial returned by - ``deflation_monom``. - - >>> ctx = fmpq_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> N, I = f.deflation_index() - >>> N, I - ([2, 3], [1, 1]) - >>> f_deflated = f.deflate(N) - >>> f_deflated - x + y + 1 - >>> m = ctx.term(exp_vec=I) - >>> m - x*y - >>> m * f_deflated.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - fmpz_mpoly_deflation(shift.val, stride.val, self.val.zpoly, self.ctx.val.zctx) - return list(stride), list(shift) - - cdef _compose_gens_(self, ctx, slong *mapping): - cdef fmpq_mpoly res = create_fmpq_mpoly(ctx) - fmpq_mpoly_compose_fmpq_mpoly_gen( - res.val, - self.val, - mapping, - self.ctx.val, - (ctx).val - ) - - return res - - -@cython.final -@cython.no_gc -cdef class _fmpq_mpoly_sort_key: - cdef fmpq_mpoly p - cdef ulong mult - - def __init__(self, tuple fac_m): - self.p = fac_m[0] - self.mult = fac_m[1] - - def __lt__(k1, _fmpq_mpoly_sort_key k2): - cdef slong nterms - cdef tuple monom1, monom2 - cdef fmpq coeff1, coeff2 - if k1.mult != k2.mult: - return k1.mult < k2.mult - nterms = min(len(k1.p), len(k2.p)) - for i in range(nterms): - monom1 = k1.p.monomial(i) - monom2 = k2.p.monomial(i) - if monom1 != monom2: - return monom1 < monom2 - coeff1 = k1.p.coefficient(i) - coeff2 = k2.p.coefficient(i) - if coeff1 != coeff2: - return coeff1 < coeff2 - return len(k1.p) < len(k2.p) - - -cdef class fmpq_mpoly_vec: - """ - A class representing a vector of fmpq_mpolys. Not present in FLINT. - """ - - def __cinit__(self, iterable_or_len, fmpq_mpoly_ctx ctx, bint double_indirect = False): - if isinstance(iterable_or_len, int): - self.length = iterable_or_len - else: - self.length = len(iterable_or_len) - - self.ctx = ctx - - self.val = libc.stdlib.malloc(self.length * sizeof(fmpq_mpoly_struct)) - for i in range(self.length): - fmpq_mpoly_init(&self.val[i], self.ctx.val) - - if double_indirect: - self.double_indirect = libc.stdlib.malloc(self.length * sizeof(fmpq_mpoly_struct *)) - if self.double_indirect is NULL: - raise MemoryError("malloc returned a null pointer") # pragma: no cover - - for i in range(self.length): - self.double_indirect[i] = &self.val[i] - else: - self.double_indirect = NULL - - def __init__(self, iterable_or_len, _, double_indirect: bool = False): - if not isinstance(iterable_or_len, int): - for i, x in enumerate(iterable_or_len): - self[i] = x - - def __dealloc__(self): - libc.stdlib.free(self.double_indirect) - for i in range(self.length): - fmpq_mpoly_clear(&self.val[i], self.ctx.val) - libc.stdlib.free(self.val) - - def __getitem__(self, x): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - cdef fmpq_mpoly z = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_set(z.val, &self.val[x], self.ctx.val) - return z - - def __setitem__(self, x, y): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - elif not typecheck(y, fmpq_mpoly): - raise TypeError("argument is not fmpq_mpoly") - elif (y).ctx is not self.ctx: - raise IncompatibleContextError(f"{(y).ctx} is not {self.ctx}") - - fmpq_mpoly_set(&self.val[x], (y).val, self.ctx.val) - - def __len__(self): - return self.length - - def __str__(self): - s = [None] * self.length - for i in range(self.length): - x = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_set(( x).val, &self.val[i], self.ctx.val) - s[i] = str(x) - return f"[{', '.join(s)}]" - - def __repr__(self): - return f"fmpq_mpoly_vec({self}, ctx={self.ctx})" - - def __richcmp__(self, other, int op): - if not (op == Py_EQ or op == Py_NE): - return NotImplemented - elif typecheck(other, fmpq_mpoly_vec): - if (self).ctx is (other).ctx and len(self) == len(other): - return (op == Py_NE) ^ all(x == y for x, y in zip(self, other)) - else: - return op == Py_NE - else: - return NotImplemented - - def __iter__(self): - cdef fmpq_mpoly z - for i in range(self.length): - z = create_fmpq_mpoly(self.ctx) - fmpq_mpoly_set(z.val, &self.val[i], self.ctx.val) - yield z diff --git a/src/flint/types/fmpq_poly.pxd b/src/flint/types/fmpq_poly.pxd deleted file mode 100644 index 6e41361d..00000000 --- a/src/flint/types/fmpq_poly.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_poly -from flint.flintlib.functions.fmpq_poly cimport fmpq_poly_t - -cdef fmpq_poly_set_list(fmpq_poly_t poly, list val) -cdef any_as_fmpq_poly(obj) -cdef class fmpq_poly(flint_poly): - cdef fmpq_poly_t val - cpdef long length(self) - cpdef long degree(self) diff --git a/src/flint/types/fmpq_poly.pyi b/src/flint/types/fmpq_poly.pyi deleted file mode 100644 index 1d65fada..00000000 --- a/src/flint/types/fmpq_poly.pyi +++ /dev/null @@ -1,96 +0,0 @@ -from typing import overload, Any, Sequence -from flint.flint_base.flint_base import flint_poly -from flint.types.fmpz import fmpz, ifmpz -from flint.types.fmpq import fmpq, ifmpq -from flint.types.fmpz_poly import fmpz_poly, ifmpz_poly - - -ifmpq_poly = fmpq_poly | ifmpq | ifmpz_poly - - -class fmpq_poly(flint_poly[fmpq]): - """ - The *fmpq_poly* type represents dense univariate polynomials - over the rational numbers. For efficiency reasons, an *fmpq_poly* is - structurally an integer polynomial with a single common denominator. - """ - - def __init__(self, other: Sequence[ifmpq] | ifmpq_poly = ..., den: ifmpz = ..., /) -> None: ... - - def __len__(self) -> int: ... - def length(self) -> int: ... - def degree(self) -> int: ... - - def numer(self) -> fmpz_poly: ... - def denom(self) -> fmpz: ... - - @property - def p(self) -> fmpz_poly: ... - @property - def q(self) -> fmpz: ... - - def __getitem__(self, i: int, /) -> fmpq: ... - def __setitem__(self, i: int, x: ifmpq, /) -> None: ... - - def repr(self) -> str: ... - - def __bool__(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_constant(self) -> bool: ... - def is_gen(self) -> bool: ... - - def leading_coefficient(self) -> fmpq: ... - - @overload - def __call__(self, other: ifmpq, /) -> fmpq: ... - @overload - def __call__(self, other: fmpq_poly | fmpz_poly, /) -> fmpq_poly: ... - - def derivative(self) -> fmpq_poly: ... - def integral(self) -> fmpq_poly: ... - - def __pos__(self) -> fmpq_poly: ... - def __neg__(self) -> fmpq_poly: ... - def __add__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __radd__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __sub__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __rsub__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __mul__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __rmul__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __floordiv__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __rfloordiv__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __mod__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __rmod__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __truediv__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __rtruediv__(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def __divmod__(self, other: ifmpq_poly, /) -> tuple[fmpq_poly, fmpq_poly]: ... - def __rdivmod__(self, other: ifmpq_poly, /) -> tuple[fmpq_poly, fmpq_poly]: ... - def __pow__(self, exp: int | ifmpz, /) -> fmpq_poly: ... - - def left_shift(self, n: int, /) -> fmpq_poly: ... - def right_shift(self, n: int, /) -> fmpq_poly: ... - def truncate(self, n: int, /) -> fmpq_poly: ... - def mul_low(self, other: fmpq_poly, n: int) -> fmpq_poly: ... - def pow_trunc(self, e: int, n: int) -> fmpq_poly: ... - - def gcd(self, other: ifmpq_poly, /) -> fmpq_poly: ... - def discriminant(self) -> fmpq: ... - def resultant(self, other: ifmpq_poly, /) -> fmpq: ... - def xgcd(self, other: ifmpq_poly, /) -> tuple[fmpq_poly, fmpq_poly, fmpq_poly]: ... - - def factor(self, *, monic: bool = False) -> tuple[fmpq, list[tuple[fmpq_poly, int]]]: ... - def factor_squarefree(self) -> tuple[fmpq, list[tuple[fmpq_poly, int]]]: ... - - def sqrt(self) -> fmpq_poly: ... - - def deflation(self) -> tuple[fmpq_poly, int]: ... - # XXX: acb - def complex_roots(self, **kwargs) -> list[Any]: ... - - @staticmethod - def bernoulli_poly(n: int, /) -> fmpq_poly: ... - @staticmethod - def euler_poly(n: int, /) -> fmpq_poly: ... - @staticmethod - def legendre_p(n: int, /) -> fmpq_poly: ... diff --git a/src/flint/types/fmpq_poly.pyx b/src/flint/types/fmpq_poly.pyx deleted file mode 100644 index 5781d8b0..00000000 --- a/src/flint/types/fmpq_poly.pyx +++ /dev/null @@ -1,778 +0,0 @@ -from cpython.list cimport PyList_Size as PyList_GET_SIZE -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_base cimport flint_poly -from flint.types.fmpz_poly cimport any_as_fmpz_poly -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq cimport fmpq -from flint.types.fmpq cimport any_as_fmpq -from flint.types.fmpz cimport fmpz -from flint.types.fmpz cimport any_as_fmpz - -from flint.flintlib.functions.fmpz cimport fmpz_is_zero -from flint.flintlib.functions.fmpz cimport fmpz_set -from flint.flintlib.functions.fmpz_poly cimport fmpz_poly_discriminant -from flint.flintlib.functions.fmpq cimport fmpq_is_zero, fmpq_set_fmpz_frac -from flint.flintlib.functions.fmpq_poly cimport * -from flint.flintlib.functions.arith cimport arith_bernoulli_polynomial -from flint.flintlib.functions.arith cimport arith_euler_polynomial -from flint.flintlib.types.arith cimport arith_legendre_polynomial - -from flint.utils.flint_exceptions import DomainError - - -cdef any_as_fmpq_poly(obj): - if typecheck(obj, fmpq_poly): - return obj - x = any_as_fmpz(obj) - if x is not NotImplemented: - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_set_fmpz((r).val, (x).val) - return r - x = any_as_fmpz_poly(obj) - if x is not NotImplemented: - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_set_fmpz_poly((r).val, (x).val) - return r - x = any_as_fmpq(obj) - if x is not NotImplemented: - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_set_fmpq((r).val, (x).val) - return r - return NotImplemented - -cdef fmpq_poly_set_list(fmpq_poly_t poly, list val): - cdef long i, n - n = PyList_GET_SIZE(val) - fmpq_poly_fit_length(poly, n) - for i from 0 <= i < n: - c = val[i] - x = any_as_fmpz(c) - if x is not NotImplemented: - fmpq_poly_set_coeff_fmpz(poly, i, (x).val) - continue - x = any_as_fmpq(c) - if x is not NotImplemented: - fmpq_poly_set_coeff_fmpq(poly, i, (x).val) - continue - raise TypeError("unsupported coefficient in list") - -cdef class fmpq_poly(flint_poly): - """ - The *fmpq_poly* type represents dense univariate polynomials - over the rational numbers. For efficiency reasons, an *fmpq_poly* is - structurally an integer polynomial with a single common denominator. - - >>> from flint import ctx - >>> fmpq_poly([1,2,3],5) ** 3 - 27/125*x^6 + 54/125*x^5 + 63/125*x^4 + 44/125*x^3 + 21/125*x^2 + 6/125*x + 1/125 - >>> ctx.pretty = False - >>> fmpq_poly([1,2,3],5) ** 3 - fmpq_poly([1, 6, 21, 44, 63, 54, 27], 125) - >>> divmod(fmpq_poly([2,0,1,1,6]), fmpq_poly([3,5,7])) - (fmpq_poly([38, -161, 294], 343), fmpq_poly([572, 293], 343)) - >>> ctx.pretty = True - - """ - - # cdef fmpq_poly_t val - - def __cinit__(self): - fmpq_poly_init(self.val) - - def __dealloc__(self): - fmpq_poly_clear(self.val) - - def __init__(self, *args): - if len(args) == 0: - return - elif len(args) > 2: - raise TypeError("fmpq_poly() takes 0, 1 or 2 arguments (%d given)" % len(args)) - - p = args[0] - if typecheck(p, fmpq_poly): - fmpq_poly_set(self.val, (p).val) - elif typecheck(p, fmpz_poly): - fmpq_poly_set_fmpz_poly(self.val, (p).val) - elif isinstance(p, list): - fmpq_poly_set_list(self.val, p) - elif (v := any_as_fmpq(p)) is not NotImplemented: - fmpq_poly_set_fmpq(self.val, (v).val) - else: - raise TypeError("cannot create fmpq_poly from input of type %s", type(p)) - - if len(args) == 2: - q = any_as_fmpz(args[1]) - if q is NotImplemented: - raise TypeError("denominator must be an integer, got %s", type(q)) - if fmpz_is_zero((q).val): - raise ZeroDivisionError("cannot create fmpq_poly with zero denominator") - fmpq_poly_scalar_div_fmpz(self.val, self.val, (q).val) - - def __len__(self): - return fmpq_poly_length(self.val) - - cpdef long length(self): - return fmpq_poly_length(self.val) - - cpdef long degree(self): - return fmpq_poly_degree(self.val) - - def __richcmp__(self, other, int op): - cdef bint r - if op != 2 and op != 3: - raise TypeError("polynomials cannot be ordered") - self = any_as_fmpq_poly(self) - if self is NotImplemented: - return self - other = any_as_fmpq_poly(other) - if other is NotImplemented: - return other - r = fmpq_poly_equal((self).val, (other).val) - if op == 3: - r = not r - return r - - def numer(self): - cdef fmpz_poly x = fmpz_poly.__new__(fmpz_poly) - fmpq_poly_get_numerator(x.val, self.val) - return x - - def denom(self): - cdef fmpz x = fmpz.__new__(fmpz) - fmpz_set(x.val, fmpq_poly_denref(self.val)) - return x - - p = property(numer) - q = property(denom) - - def __getitem__(self, long i): - cdef fmpq x - x = fmpq() - if i < 0: - return x - fmpq_poly_get_coeff_fmpq(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if not typecheck(x, fmpq): - x = fmpq(x) - fmpq_poly_set_coeff_fmpq(self.val, i, (x).val) - - def repr(self): - d = self.denom() - n = self.numer() - if d == 1: - return "fmpq_poly(%s)" % [int(c) for c in n.coeffs()] - else: - return "fmpq_poly(%s, %s)" % ([int(c) for c in n.coeffs()], d) - - def __bool__(self): - return not fmpq_poly_is_zero(self.val) - - def is_zero(self): - """ - Returns True if this is the zero polynomial. - """ - return fmpq_poly_is_zero(self.val) - - def is_one(self): - """ - Returns True if this polynomial is equal to 1. - """ - return fmpq_poly_is_one(self.val) - - def is_constant(self): - """ - Returns True if this polynomial is a scalar (constant). - - >>> f = fmpq_poly([0, 1]) - >>> f - x - >>> f.is_constant() - False - """ - return fmpq_poly_degree(self.val) <= 0 - - def is_gen(self): - """ - Return ``True`` if the polynomial is the generator - of the polynomial, `x`, and ``False`` otherwise - - >>> x = fmpq_poly([0, 1]) - >>> x - x - >>> x.is_gen() - True - >>> (x + 1).is_gen() - False - """ - return fmpq_poly_is_gen(self.val) - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then a copy of ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> f = fmpq_poly([1,2,3]) - >>> f.truncate(3) == f - True - >>> f.truncate(2) - 2*x + 1 - >>> f.truncate(1) - 1 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - - """ - cdef fmpq_poly res - res = fmpq_poly.__new__(fmpq_poly) - - length = fmpq_poly_length(self.val) - if n <= 0: # return zero - return res - elif n > length: # do nothing - fmpq_poly_set(res.val, self.val) - else: - fmpq_poly_set_trunc(res.val, self.val, n) - - return res - - def leading_coefficient(self): - """ - Returns the leading coefficient of the polynomial. - - >>> f = fmpq_poly([1, 2, 3]) - >>> f - 3*x^2 + 2*x + 1 - >>> f.leading_coefficient() - 3 - """ - cdef fmpq x - cdef slong d - d = fmpq_poly_degree(self.val) - x = fmpq.__new__(fmpq) - if d >= 0: - fmpq_poly_get_coeff_fmpq(x.val, self.val, d) - return x - - def __call__(self, other): - t = any_as_fmpz(other) - if t is not NotImplemented: - v = fmpq.__new__(fmpq) - fmpq_poly_evaluate_fmpz((v).val, self.val, (t).val) - return v - t = any_as_fmpq(other) - if t is not NotImplemented: - v = fmpq.__new__(fmpq) - fmpq_poly_evaluate_fmpq((v).val, self.val, (t).val) - return v - t = any_as_fmpq_poly(other) - if t is not NotImplemented: - v = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_compose((v).val, self.val, (t).val) - return v - raise TypeError("cannot call fmpq_poly with input of type %s", type(other)) - - def derivative(self): - cdef fmpq_poly res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_derivative(res.val, self.val) - return res - - def integral(self): - cdef fmpq_poly res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_integral(res.val, self.val) - return res - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpq_poly res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_neg(res.val, self.val) - return res - - def _add_(s, t): - cdef fmpq_poly r - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_add(r.val, (s).val, (t).val) - return r - - def __add__(s, t): - return s._add_(t) - - def __radd__(s, t): - return s._add_(t) - - def _sub_(s, t): - cdef fmpq_poly r - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_sub(r.val, (s).val, (t).val) - return r - - def __sub__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return s._sub_(t) - - def __rsub__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return t._sub_(s) - - def _mul_(s, t): - cdef fmpq_poly r - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_mul(r.val, (s).val, (t).val) - return r - - def __mul__(s, t): - return s._mul_(t) - - def __rmul__(s, t): - return s._mul_(t) - - def _floordiv_(s, t): - cdef fmpq_poly r - if fmpq_poly_is_zero((t).val): - raise ZeroDivisionError("fmpq_poly division by 0") - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_div(r.val, (s).val, (t).val) - return r - - def __floordiv__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return s._floordiv_(t) - - def __rfloordiv__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return t._floordiv_(s) - - def _mod_(s, t): - cdef fmpq_poly r - if fmpq_poly_is_zero((t).val): - raise ZeroDivisionError("fmpq_poly division by 0") - r = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_rem(r.val, (s).val, (t).val) - return r - - def __mod__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return s._mod_(t) - - def __rmod__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return t._mod_(s) - - def __truediv__(fmpq_poly s, t): - cdef fmpq_poly res - cdef fmpq_poly_t r - t2 = any_as_fmpq(t) - if t2 is NotImplemented: - t2 = any_as_fmpq_poly(t) - if t2 is NotImplemented: - return t2 - if fmpq_poly_is_zero((t2).val): - raise ZeroDivisionError("fmpq_poly division by 0") - res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_init(r) - fmpq_poly_divrem(res.val, r, (s).val, (t2).val) - exact = fmpq_poly_is_zero(r) - fmpq_poly_clear(r) - if not exact: - raise DomainError("fmpq_poly inexact division") - else: - if fmpq_is_zero((t2).val): - raise ZeroDivisionError("fmpq_poly scalar division by 0") - res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_scalar_div_fmpq(res.val, (s).val, (t2).val) - return res - - def __rtruediv__(fmpq_poly s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return t / s - - def _divmod_(s, t): - cdef fmpq_poly P, Q - if fmpq_poly_is_zero((t).val): - raise ZeroDivisionError("fmpq_poly divmod by 0") - P = fmpq_poly.__new__(fmpq_poly) - Q = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_divrem(P.val, Q.val, (s).val, (t).val) - return P, Q - - def __divmod__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return s._divmod_(t) - - def __rdivmod__(s, t): - t = any_as_fmpq_poly(t) - if t is NotImplemented: - return t - return t._divmod_(s) - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> 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 - - """ - cdef fmpq_poly res - res = fmpq_poly.__new__(fmpq_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - fmpq_poly_shift_left(res.val, self.val, n) - else: # do nothing, just copy self - fmpq_poly_set(res.val, self.val) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> 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 - """ - cdef fmpq_poly res - res = fmpq_poly.__new__(fmpq_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - fmpq_poly_shift_right(res.val, self.val, n) - else: # do nothing, just copy self - fmpq_poly_set(res.val, self.val) - - return res - - def __pow__(fmpq_poly self, exp, mod): - cdef fmpq_poly res - if mod is not None: - raise NotImplementedError("fmpz_poly modular exponentiation") - if exp < 0: - self = 1 / self - exp = -exp - res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_pow(res.val, self.val, exp) - return res - - def mul_low(self, other, slong n): - r""" - Returns the lowest ``n`` coefficients of the multiplication of ``self`` with ``other`` - - Equivalent to computing `f(x) \cdot g(x) \mod x^n` - - >>> f = fmpq_poly([2,3,5,7,11]) - >>> g = fmpq_poly([1,2,4,8,16]) - >>> f.mul_low(g, 5) - 101*x^4 + 45*x^3 + 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 3) - 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 1) - 2 - """ - # Only allow multiplication with other fmpq_poly - if not typecheck(other, fmpq_poly): - raise TypeError("other polynomial must be of type fmpq_poly") - - cdef fmpq_poly res - res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_mullow(res.val, self.val, (other).val, n) - return res - - def pow_trunc(self, e, slong n): - r""" - Returns ``self`` raised to the power ``e`` modulo `x^n`: - :math:`f^e \mod x^n`/ - - >>> f = fmpq_poly([1, 2, 3]) - >>> x = fmpq_poly([0, 1]) - >>> f.pow_trunc(2**20, 4) - 1537230871828889600*x^3 + 2199024304128*x^2 + 2097152*x + 1 - >>> f.pow_trunc(5**25, 3) - 177635683940025046765804290771484375*x^2 + 596046447753906250*x + 1 - """ - if e < 0: - raise ValueError("Exponent must be non-negative") - - cdef slong e_c - cdef fmpq_poly res, tmp - - try: - e_c = e - except OverflowError: - # Exponent does not fit slong - res = fmpq_poly.__new__(fmpq_poly) - tmp = fmpq_poly.__new__(fmpq_poly) - ebytes = e.to_bytes((e.bit_length() + 15) // 16 * 2, "big") - fmpq_poly_pow_trunc(res.val, self.val, ebytes[0] * 256 + ebytes[1], n) - for i in range(2, len(ebytes), 2): - fmpq_poly_pow_trunc(res.val, res.val, 1 << 16, n) - fmpq_poly_pow_trunc(tmp.val, self.val, ebytes[i] * 256 + ebytes[i+1], n) - fmpq_poly_mullow(res.val, res.val, tmp.val, n) - return res - - res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_pow_trunc(res.val, self.val, e_c, n) - return res - - def gcd(self, other): - """ - Returns the greatest common divisor of *self* and *other*. - - >>> A = fmpq_poly([1,2,6],6); B = fmpq_poly([4,2,1],12) - >>> (A * B).gcd(B) - x^2 + 2*x + 4 - - """ - cdef fmpq_poly res - other = any_as_fmpq_poly(other) - if other is NotImplemented: - raise TypeError("cannot convert input to fmpq_poly") - res = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_gcd(res.val, self.val, (other).val) - return res - - def discriminant(self): - """ - Return the discriminant of ``self``. - - >>> 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 - - """ - # There is no FLINT function for the discriminant of a fmpq_poly, - # we use the fact that disc(f/q) = disc(f)/q^(2d-2) - cdef fmpq res = fmpq.__new__(fmpq) - cdef fmpz rnum = fmpz.__new__(fmpz) - cdef fmpz rden = self.denom()**(2 * self.degree() - 2) - - cdef fmpz_poly x = fmpz_poly.__new__(fmpz_poly) - fmpq_poly_get_numerator(x.val, self.val) - fmpz_poly_discriminant(rnum.val, x.val) - fmpq_set_fmpz_frac(res.val, rnum.val, rden.val) - - return res - - def resultant(self, other): - """ - Returns the resultant of *self* and *other*. - - >>> 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 - - """ - cdef fmpq res - other = any_as_fmpq_poly(other) - if other is NotImplemented: - raise TypeError("cannot convert input to fmpq_poly") - - res = fmpq.__new__(fmpq) - fmpq_poly_resultant(res.val, self.val, (other).val) - return res - - def xgcd(self, other): - cdef fmpq_poly res1, res2, res3 - other = any_as_fmpq_poly(other) - if other is NotImplemented: - raise TypeError("cannot convert input to fmpq_poly") - res1 = fmpq_poly.__new__(fmpq_poly) - res2 = fmpq_poly.__new__(fmpq_poly) - res3 = fmpq_poly.__new__(fmpq_poly) - fmpq_poly_xgcd(res1.val, res2.val, res3.val, self.val, (other).val) - return (res1, res2, res3) - - def factor(self, *, monic=False): - """ - Factors *self* into irreducible polynomials. Returns (*c*, *factors*) - where *c* is the leading coefficient and *factors* is a list of - (*poly*, *exp*). - - >>> 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)]) - - Since python-flint 0.7.0 this returns primitive denominator-free - factors consistent with ``fmpq_mpoly.factor()``. In previous versions - of python-flint all factors were made monic. Pass ``monic=True`` to get - monic factors instead. - - >>> 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)]) - - """ - c, fac = self.numer().factor() - c = fmpq(c) - - if monic: - for i in range(len(fac)): - base, exp = fac[i] - lead = base[base.degree()] - base = fmpq_poly(base, lead) - c *= lead ** exp - fac[i] = (base, exp) - else: - fac = [(fmpq_poly(f), m) for f, m in fac] - - return c / self.denom(), fac - - def factor_squarefree(self): - """ - Factors *self* into square-free polynomials. Returns (*c*, *factors*) - where *c* is the leading coefficient and *factors* is a list of - (*poly*, *exp*). - - >>> 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)]) - - """ - c, fac = self.numer().factor_squarefree() - c = fmpq(c) / self.denom() - fac = [(fmpq_poly(f), m) for f, m in fac] - return c, fac - - def sqrt(self): - """ - Return the exact square root of this polynomial or ``None``. - - >>> p = fmpq_poly([1,2,1],4) - >>> p - 1/4*x^2 + 1/2*x + 1/4 - >>> p.sqrt() - 1/2*x + 1/2 - - """ - d = self.denom() - n = self.numer() - d, r = d.sqrtrem() - if r != 0: - raise ValueError(f"Cannot compute square root of {self}") - n = n.sqrt() - if n is None: - raise ValueError(f"Cannot compute square root of {self}") - return fmpq_poly(n, d) - - def deflation(self): - num, n = self.numer().deflation() - num = fmpq_poly(num, self.denom()) - return num, n - - def complex_roots(self, **kwargs): - """ - Computes the complex roots of this polynomial. See - :meth:`.fmpz_poly.roots`. - - >>> from flint import fmpq, ctx - >>> ctx.prec = 53 - >>> fmpq_poly([fmpq(2,3),1]).complex_roots() - [([-0.666666666666667 +/- 3.34e-16], 1)] - """ - return self.numer().complex_roots(**kwargs) - - @staticmethod - def bernoulli_poly(n): - r""" - Returns the Bernoulli polynomial `B_n(x)` as an *fmpq_poly*. - - >>> fmpq_poly.bernoulli_poly(2) - x^2 + (-1)*x + 1/6 - """ - cdef fmpq_poly v = fmpq_poly() - arith_bernoulli_polynomial(v.val, n) - return v - - @staticmethod - def euler_poly(n): - r""" - Returns the Euler polynomial `E_n(x)` as an *fmpq_poly*. - - >>> fmpq_poly.euler_poly(3) - x^3 + (-3/2)*x^2 + 1/4 - """ - cdef fmpq_poly v = fmpq_poly() - arith_euler_polynomial(v.val, n) - return v - - @staticmethod - def legendre_p(n): - r""" - Returns the Legendre polynomial `P_n(x)` as an *fmpq_poly*. - - >>> fmpq_poly.legendre_p(3) - 5/2*x^3 + (-3/2)*x - - """ - cdef fmpq_poly v = fmpq_poly() - arith_legendre_polynomial(v.val, n) - return v diff --git a/src/flint/types/fmpq_series.pxd b/src/flint/types/fmpq_series.pxd deleted file mode 100644 index e1e02a01..00000000 --- a/src/flint/types/fmpq_series.pxd +++ /dev/null @@ -1,10 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series -from flint.flintlib.functions.fmpq_poly cimport fmpq_poly_t - -cdef class fmpq_series(flint_series): - cdef fmpq_poly_t val - cdef long _prec - cpdef long length(self) - cpdef valuation(self) - cdef bint zero_constant_term(s) - cdef bint one_constant_term(s) diff --git a/src/flint/types/fmpq_series.pyi b/src/flint/types/fmpq_series.pyi deleted file mode 100644 index 8ac0c3ee..00000000 --- a/src/flint/types/fmpq_series.pyi +++ /dev/null @@ -1,78 +0,0 @@ -from typing import Any, Sequence -from flint.flint_base.flint_base import flint_series -from flint.types.fmpz import fmpz, ifmpz -from flint.types.fmpq import fmpq, ifmpq -from flint.types.fmpq_poly import fmpq_poly -from flint.types.fmpz_series import fmpz_series, ifmpz_series - - -ifmpq_series = fmpq_series | fmpq_poly | ifmpz_series - - -class fmpq_series(flint_series[fmpq]): - """Approximate truncated power series with rational coefficients.""" - - def __init__(self, - val: Sequence[ifmpq] | ifmpq | ifmpq_series | None = None, - den: ifmpz | None = None, - prec: int | None = None): ... - - @property - def prec(self) -> int: ... - - def _equal_repr(self, other: object) -> bool: ... - - def __len__(self) -> int: ... - def length(self) -> int: ... - - def numer(self) -> fmpz_series: ... - def denom(self) -> fmpz: ... - - @property - def p(self) -> fmpq_poly: ... - @property - def q(self) -> fmpz: ... - - def __getitem__(self, i: int, /) -> fmpq: ... - def __setitem__(self, i: int, x: ifmpq, /) -> None: ... - - def repr(self, **kwargs: Any) -> str: ... - def str(self, **kwargs: Any) -> str: ... - - def __pos__(self) -> fmpq_series: ... - def __neg__(self) -> fmpq_series: ... - def __add__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __radd__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __sub__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __rsub__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __mul__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __rmul__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __truediv__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __rtruediv__(self, other: ifmpq_series, /) -> fmpq_series: ... - def __pow__(self, exp: int, /) -> fmpq_series: ... - - def valuation(self) -> int: ... - - def __call__(self, other: ifmpq_series, /) -> fmpq_series: ... - def reversion(self) -> fmpq_series: ... - def inv(self) -> fmpq_series: ... - - def zero_constant_term(self) -> bool: ... - def one_constant_term(self) -> bool: ... - - def derivative(self) -> fmpq_series: ... - def integral(self) -> fmpq_series: ... - def sqrt(self) -> fmpq_series: ... - def rsqrt(self) -> fmpq_series: ... - def exp(self) -> fmpq_series: ... - def log(self) -> fmpq_series: ... - def atan(self) -> fmpq_series: ... - def atanh(self) -> fmpq_series: ... - def asin(self) -> fmpq_series: ... - def asinh(self) -> fmpq_series: ... - def sin(self) -> fmpq_series: ... - def cos(self) -> fmpq_series: ... - def tan(self) -> fmpq_series: ... - def sinh(self) -> fmpq_series: ... - def cosh(self) -> fmpq_series: ... - def tanh(self) -> fmpq_series: ... diff --git a/src/flint/types/fmpq_series.pyx b/src/flint/types/fmpq_series.pyx deleted file mode 100644 index a99f530c..00000000 --- a/src/flint/types/fmpq_series.pyx +++ /dev/null @@ -1,574 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_context cimport getcap -from flint.types.fmpz_series cimport fmpz_series -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.fmpq_poly cimport fmpq_poly_set_list -from flint.types.fmpz cimport fmpz -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq cimport fmpq -from flint.types.arb cimport arb -from flint.types.arb_poly cimport arb_poly -from flint.types.arb_series cimport arb_series -from flint.types.acb cimport acb -from flint.types.acb_poly cimport acb_poly -from flint.types.acb_series cimport acb_series -from flint.types.fmpz cimport any_as_fmpz - -from flint.flintlib.functions.fmpz cimport fmpz_is_zero, fmpz_set, fmpz_equal -from flint.flintlib.functions.fmpq_poly cimport * - -cdef fmpq_series_coerce_operands(x, y): - if isinstance(y, (int, fmpz, fmpz_poly, fmpz_series, fmpq, fmpq_poly)): - return x, fmpq_series(y) - # if isinstance(y, (nmod, nmod_poly, nmod_series)): - # return nmod_series(x), nmod_series(y) - if isinstance(y, (float, arb, arb_poly, arb_series)): - return arb_series(x), arb_series(y) - if isinstance(y, (complex, acb, acb_poly, acb_series)): - return acb_series(x), acb_series(y) - return NotImplemented, NotImplemented - -cdef class fmpq_series(flint_series): - - """ - Approximate truncated power series with rational coefficients. - - >>> from flint import fmpq_series, ctx - >>> ctx.cap = 10 - - >>> fmpq_series([1,2,3]) - 1 + 2*x + 3*x^2 + O(x^10) - >>> fmpq_series([1,2,3], prec=2) - 1 + 2*x + O(x^2) - - >>> x = fmpq_series([0,1]) - >>> x - x + O(x^10) - >>> 1/(x+1) - 1 + (-1)*x + x^2 + (-1)*x^3 + x^4 + (-1)*x^5 + x^6 + (-1)*x^7 + x^8 + (-1)*x^9 + O(x^10) - >>> x.sin() - x + (-1/6)*x^3 + 1/120*x^5 + (-1/5040)*x^7 + 1/362880*x^9 + O(x^10) - - Elements can have greater or less precision than the context's ``cap`` - but operations will be truncated to ``cap`` terms. - - """ - - # cdef fmpq_poly_t val - # cdef long _prec - - def __cinit__(self): - fmpq_poly_init(self.val) - self._prec = 0 - - def __dealloc__(self): - fmpq_poly_clear(self.val) - - def __init__(self, val=None, den=None, prec=None): - if prec is None: - self._prec = getcap() - else: - self._prec = prec - if self._prec < 0: - self._prec = -1 - if val is not None: - if typecheck(val, fmpq_series): - fmpq_poly_set(self.val, (val).val) - self._prec = min((val)._prec, self._prec) - elif typecheck(val, fmpz_series): - fmpq_poly_set_fmpz_poly(self.val, (val).val) - self._prec = min((val)._prec, self._prec) - elif typecheck(val, fmpz_poly): - fmpq_poly_set_fmpz_poly(self.val, (val).val) - elif typecheck(val, fmpq_poly): - fmpq_poly_set(self.val, (val).val) - elif typecheck(val, list): - fmpq_poly_set_list(self.val, val) - else: - fmpq_poly_set_list(self.val, [val]) - fmpq_poly_truncate(self.val, max(0, self._prec)) - if den is not None: - den = any_as_fmpz(den) - if den is NotImplemented: - raise TypeError("denominator must be an integer, got %s", type(den)) - if fmpz_is_zero((den).val): - raise ZeroDivisionError("cannot create fmpq_series with zero denominator") - fmpq_poly_scalar_div_fmpz(self.val, self.val, (den).val) - - @property - def prec(self): - """ - The term precision of the finitely approximated series. - - >>> from flint import fmpq_series, ctx - >>> ctx.cap = 10 - >>> s = fmpq_series([1,2]) - >>> s - 1 + 2*x + O(x^10) - >>> s.prec - 10 - >>> s2 = fmpq_series([1,2], prec=3) - >>> s2 - 1 + 2*x + O(x^3) - >>> s2.prec - 3 - """ - return self._prec - - def _equal_repr(s, t): - cdef bint r - if not typecheck(t, fmpq_series): - return False - r = fmpq_poly_equal((s).val, (t).val) - if r: - r = (s)._prec == (t)._prec - return r - - def __len__(self): - return fmpq_poly_length(self.val) - - cpdef long length(self): - return fmpq_poly_length(self.val) - - def numer(self): - cdef fmpz_series x = fmpz_series.__new__(fmpz_series) - fmpq_poly_get_numerator(x.val, self.val) - x._prec = self._prec - return x - - def denom(self): - cdef fmpz x = fmpz.__new__(fmpz) - fmpz_set(x.val, fmpq_poly_denref(self.val)) - return x - - p = property(numer) - q = property(denom) - - def __getitem__(self, long i): - cdef fmpq x - x = fmpq() - if i < 0: - return x - fmpq_poly_get_coeff_fmpq(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if not typecheck(x, fmpq): - x = fmpq(x) - fmpq_poly_set_coeff_fmpq(self.val, i, (x).val) - - def repr(self, **kwargs): - return "fmpq_series([%s], %s, prec=%s)" % (", ".join(map(str, self.numer())), str(self.denom()), self._prec) - - def str(self, **kwargs): - if self._prec > 0: - s = fmpq_poly(list(self)).str(ascending=True) - return s + (" + O(x^%s)" % self._prec) - elif self._prec == 0: - return "O(x^0)" - else: - return "(invalid power series)" - - def __pos__(self): - return self - - def __neg__(s): - cdef long cap - u = fmpq_series.__new__(fmpq_series) - cap = getcap() - cap = min(cap, (s)._prec) - if cap > 0: - fmpq_poly_neg((u).val, (s).val) - fmpq_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __add__(s, t): - if not isinstance(t, fmpq_series): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - cdef long cap - u = fmpq_series.__new__(fmpq_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - fmpq_poly_add((u).val, (s).val, (t).val) - fmpq_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __radd__(s, t): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - if not isinstance(t, fmpq_series): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - cdef long cap - u = fmpq_series.__new__(fmpq_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - fmpq_poly_sub((u).val, (s).val, (t).val) - fmpq_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __rsub__(s, t): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def __mul__(s, t): - if not isinstance(t, fmpq_series): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - cdef long cap - u = fmpq_series.__new__(fmpq_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - fmpq_poly_mullow((u).val, (s).val, (t).val, cap) - (u)._prec = cap - return u - - def __rmul__(s, t): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - cpdef valuation(self): - cdef long i - if fmpq_poly_is_zero(self.val): - return -1 - i = 0 - while fmpz_is_zero(&(self.val.coeffs[i])): - i += 1 - return i - - @staticmethod - def _div_(s, t): - cdef long cap, sval, tval - cdef fmpq_poly_t stmp, ttmp - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - - if fmpq_poly_is_zero((t).val): - raise ZeroDivisionError("power series division") - - u = fmpq_series.__new__(fmpq_series) - - if fmpq_poly_is_zero((s).val): - (u)._prec = cap - return u - - sval = (s).valuation() - tval = (t).valuation() - - if sval < tval: - raise ValueError("quotient would not be a power series") - - if fmpz_is_zero(&((t).val.coeffs[tval])): - raise ValueError("leading term in denominator is not a unit") - - if tval == 0: - fmpq_poly_div_series((u).val, (s).val, (t).val, cap) - else: - fmpq_poly_init(stmp) - fmpq_poly_init(ttmp) - fmpq_poly_shift_right(stmp, (s).val, tval) - fmpq_poly_shift_right(ttmp, (t).val, tval) - cap -= tval - fmpq_poly_div_series((u).val, stmp, ttmp, cap) - fmpq_poly_clear(stmp) - fmpq_poly_clear(ttmp) - - (u)._prec = cap - return u - - def __truediv__(s, t): - if not isinstance(t, fmpq_series): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s / t - return fmpq_series._div_(s, t) - - def __rtruediv__(s, t): - s, t = fmpq_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t / s - - # generic exponentiation (fallback code) - # XXX: use fmpq_poly_pow_trunc instead? - def __pow__(s, ulong exp, mod): - if mod is not None: - raise NotImplementedError("modular exponentiation") - cdef long i - if exp == 0: - return (s * 0) + 1 - if exp == 1: - return s - if exp == 2: - return s * s - y = s - bits = exp.bit_length() - for i in range(bits-2, -1, -1): - y = y * y - if (exp >> i) & 1: - y = y * s - return y - - def __call__(s, t): - cdef long cap - if typecheck(t, fmpq_series): - u = fmpq_series.__new__(fmpq_series) - if (t).valuation() < 1: - raise ValueError("power series composition with nonzero constant term") - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - fmpq_poly_compose_series((u).val, (s).val, (t).val, cap) - (u)._prec = cap - return u - raise TypeError("cannot call fmpq_series with input of type %s", type(t)) - - def reversion(s): - """ - Returns the power series reversion (compositional inverse) of *s*. - - >>> from flint import fmpq_series, ctx - >>> ctx.cap = 10 - - >>> x = fmpq_series([0,1]); print((x/2-x**2).reversion()) - 2*x + 8*x^2 + 64*x^3 + 640*x^4 + 7168*x^5 + 86016*x^6 + 1081344*x^7 + 14057472*x^8 + 187432960*x^9 + O(x^10) - """ - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if (s).valuation() != 1: - raise ValueError("power series reversion must have valuation 1") - if fmpz_is_zero(&((s).val.coeffs[1])): - raise ValueError("leading term is not a unit") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_revert_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def inv(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if (s).valuation() != 0: - raise ValueError("can only invert series with nonzero constant term") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_inv_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - cdef bint zero_constant_term(s): - if fmpq_poly_is_zero((s).val): - return True - if fmpz_is_zero(&((s).val.coeffs[0])): - return True - return False - - cdef bint one_constant_term(s): - if fmpq_poly_is_zero((s).val): - return False - if fmpz_equal(&((s).val.coeffs[0]), (s).val.den): - return True - return False - - def derivative(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec - 1) - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_derivative((u).val, (s).val) - fmpq_poly_truncate((u).val, max(0, cap)) - (u)._prec = cap - return u - - def integral(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec + 1) - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_integral((u).val, (s).val) - fmpq_poly_truncate((u).val, max(0, cap)) - (u)._prec = cap - return u - - def sqrt(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.one_constant_term(): - raise ValueError("sqrt() of power series: constant term != 1") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_sqrt_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def rsqrt(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.one_constant_term(): - raise ValueError("rsqrt() of power series: constant term != 1") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_invsqrt_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def exp(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("exp() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_exp_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def log(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.one_constant_term(): - raise ValueError("log() of power series: constant term must be one") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_log_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def atan(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("atan() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_atan_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def atanh(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("atanh() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_atanh_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def asin(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("asin() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_asin_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def asinh(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("asinh() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_asinh_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def sin(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("sin() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_sin_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def cos(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("cos() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_cos_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def tan(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("tan() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_tan_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def sinh(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("sinh() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_sinh_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def cosh(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("cosh() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_cosh_series((u).val, (s).val, cap) - (u)._prec = cap - return u - - def tanh(s): - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if not s.zero_constant_term(): - raise ValueError("tanh() of power series: constant term must be zero") - u = fmpq_series.__new__(fmpq_series) - fmpq_poly_tanh_series((u).val, (s).val, cap) - (u)._prec = cap - return u diff --git a/src/flint/types/fmpq_vec.pxd b/src/flint/types/fmpq_vec.pxd deleted file mode 100644 index 08db8d39..00000000 --- a/src/flint/types/fmpq_vec.pxd +++ /dev/null @@ -1,7 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.fmpq cimport fmpq_struct - -cdef class fmpq_vec: - cdef fmpq_struct *val - cdef fmpq_struct **double_indirect - cdef slong length diff --git a/src/flint/types/fmpq_vec.pyx b/src/flint/types/fmpq_vec.pyx deleted file mode 100644 index bb82662b..00000000 --- a/src/flint/types/fmpq_vec.pyx +++ /dev/null @@ -1,88 +0,0 @@ -from flint.flintlib.types.fmpq cimport fmpq_struct -from flint.flintlib.functions.fmpq cimport fmpq_set, fmpq_init -from flint.flintlib.functions.fmpq_vec cimport _fmpq_vec_init, _fmpq_vec_clear - -from flint.types.fmpq cimport fmpq, any_as_fmpq - -cimport libc.stdlib - -cdef class fmpq_vec: - def __cinit__(self, iterable_or_len, bint double_indirect=False): - if isinstance(iterable_or_len, int): - self.length = iterable_or_len - else: - self.length = len(iterable_or_len) - - self.val = _fmpq_vec_init(self.length) - - if double_indirect: - self.double_indirect = libc.stdlib.malloc(self.length * sizeof(fmpq_struct *)) - if self.double_indirect is NULL: - raise MemoryError("malloc returned a null pointer") - - for i in range(self.length): - self.double_indirect[i] = &self.val[i] - else: - self.double_indirect = NULL - - def __init__(self, iterable_or_len, double_indirect: bool = False): - if not isinstance(iterable_or_len, int): - for i, x in enumerate(iterable_or_len): - self[i] = x - - def __dealloc__(self): - libc.stdlib.free(self.double_indirect) - if self.val is not NULL: - _fmpq_vec_clear(self.val, self.length) - self.val = NULL - - def __getitem__(self, x): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - cdef fmpq z = fmpq.__new__(fmpq) - fmpq_init(z.val) - fmpq_set(z.val, &self.val[x]) - return z - - def __setitem__(self, x, y): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - y = any_as_fmpq(y) - if y is NotImplemented: - raise TypeError("argument is not coercible to fmpq") - - fmpq_set(&self.val[x], (y).val) - - def __len__(self): - return self.length - - def __str__(self): - return self.str() - - def __repr__(self): - return self.repr() - - def __iter__(self): - cdef fmpq z - for i in range(self.length): - z = fmpq.__new__(fmpq) - fmpq_set(z.val, &self.val[i]) - yield z - - def str(self, *args): - s = [None] * self.length - for i in range(self.length): - x = fmpq.__new__(fmpq) - fmpq_init(x.val) - fmpq_set(x.val, &self.val[i]) - s[i] = x.str(*args) - return str(s) - - def repr(self, *args): - return f"fmpq_vec({self.str(*args)}, {self.length})" diff --git a/src/flint/types/fmpz.pxd b/src/flint/types/fmpz.pxd deleted file mode 100644 index 4477daf0..00000000 --- a/src/flint/types/fmpz.pxd +++ /dev/null @@ -1,60 +0,0 @@ -from cpython.long cimport PyLong_Check -from flint.flint_base.flint_base cimport flint_scalar -from flint.utils.conversion cimport chars_from_str -from flint.flintlib.types.flint cimport slong, ulong, pylong_as_slong -from flint.flintlib.types.flint cimport PyObject -from flint.flintlib.functions.fmpz cimport fmpz_t, fmpz_set_si, fmpz_set_signed_ui_array -import sys - -cdef int fmpz_set_any_ref(fmpz_t x, obj) -cdef fmpz_get_intlong(fmpz_t x) - -cdef int is_big_endian = int(sys.byteorder == "big") - -cdef inline ulong ulong_from_little_endian(unsigned char *ptr): - # Read a ulong from little-endian bytes - cdef ulong w = 0 - for i in range(sizeof(ulong) // 8): - w = (w << 8) | ptr[i] - return w - -cdef inline int fmpz_set_pylong(fmpz_t x, obj): - cdef int overflow - cdef slong longval - cdef slong size - cdef bytes b - cdef ulong w - cdef ulong *words - cdef int i - - longval = pylong_as_slong(obj, &overflow) - if overflow: - # make sure the sign bit fits - # we need 8 * sizeof(ulong) * size > obj.bit_length() - size = obj.bit_length() // (8 * sizeof(ulong)) + 1 - b = obj.to_bytes(sizeof(ulong) * size, "little", signed=True) - # b is a local Python object, we access the internal pointer - words = (b) - if is_big_endian: - for i in range(size): - words[i] = ulong_from_little_endian((words + i)) - fmpz_set_signed_ui_array(x, words, size) - else: - fmpz_set_si(x, longval) - -cdef inline int fmpz_set_python(fmpz_t x, obj): - if PyLong_Check(obj): - fmpz_set_pylong(x, obj) - return 1 - return 0 -cdef any_as_fmpz(obj) - -cdef class fmpz(flint_scalar): - """ - The *fmpz* type represents an arbitrary-size integer. - - >>> fmpz(3) ** 25 - 847288609443 - - """ - cdef fmpz_t val diff --git a/src/flint/types/fmpz.pyi b/src/flint/types/fmpz.pyi deleted file mode 100644 index a94df7b8..00000000 --- a/src/flint/types/fmpz.pyi +++ /dev/null @@ -1,112 +0,0 @@ -# -# It would be better if many methods accepted SupportsIndex rather than just -# ifmpz but for now these annotations are accurate. -# -from ..flint_base.flint_base import flint_scalar - -_str = str -ifmpz = int | fmpz - -class fmpz(flint_scalar): - def __init__(self, arg: ifmpz | _str = 0, /): ... - - @property - def numerator(self) -> fmpz: ... - @property - def denominator(self) -> fmpz: ... - - def bit_length(self) -> int: ... - def height_bits(self, signed: bool = False) -> int: ... - - def str(self, base: int = 10, condense: int = 0) -> _str: ... - def repr(self) -> _str: ... - - def __str__(self) -> _str: ... - def __repr__(self) -> _str: ... - - def __int__(self) -> int: ... - def __index__(self) -> int: ... - - def __floor__(self) -> fmpz: ... - def __ceil__(self) -> fmpz: ... - def __trunc__(self) -> fmpz: ... - def __round__(self, ndigits: int | None = None) -> fmpz: ... - - def __eq__(self, other: object, /) -> bool: ... - def __hash__(self) -> int: ... - - def __lt__(self, other: ifmpz, /) -> bool: ... - def __le__(self, other: ifmpz, /) -> bool: ... - def __gt__(self, other: ifmpz, /) -> bool: ... - def __ge__(self, other: ifmpz, /) -> bool: ... - - def __neg__(self) -> fmpz: ... - def __pos__(self) -> fmpz: ... - def __add__(self, other: ifmpz, /) -> fmpz: ... - def __radd__(self, other: int, /) -> fmpz: ... - def __sub__(self, other: ifmpz, /) -> fmpz: ... - def __rsub__(self, other: int, /) -> fmpz: ... - def __mul__(self, other: ifmpz, /) -> fmpz: ... - def __rmul__(self, other: int, /) -> fmpz: ... - def __truediv__(self, other: ifmpz, /) -> fmpz: ... - def __rtruediv__(self, other: int, /) -> fmpz: ... - def __floordiv__(self, other: ifmpz, /) -> fmpz: ... - def __rfloordiv__(self, other: int, /) -> fmpz: ... - def __mod__(self, other: ifmpz, /) -> fmpz: ... - def __rmod__(self, other: int, /) -> fmpz: ... - def __divmod__(self, other: ifmpz, /) -> tuple[fmpz, fmpz]: ... - def __rdivmod__(self, other: int, /) -> tuple[fmpz, fmpz]: ... - def __pow__(self, other: ifmpz, modulo: int | fmpz | None = None, /) -> fmpz: ... - def __rpow__(self, other: int, modulo: ifmpz | None = None, /) -> fmpz: ... - def __abs__(self) -> fmpz: ... - - def __lshift__(self, other: ifmpz, /) -> fmpz: ... - def __rlshift__(self, other: ifmpz, /) -> fmpz: ... - def __rshift__(self, other: ifmpz, /) -> fmpz: ... - def __rrshift__(self, other: ifmpz, /) -> fmpz: ... - def __and__(self, other: ifmpz, /) -> fmpz: ... - def __rand__(self, other: int, /) -> fmpz: ... - def __or__(self, other: ifmpz, /) -> fmpz: ... - def __ror__(self, other: int, /) -> fmpz: ... - def __xor__(self, other: ifmpz, /) -> fmpz: ... - def __rxor__(self, other: int, /) -> fmpz: ... - def __invert__(self) -> fmpz: ... - - def gcd(self, other: ifmpz, /) -> fmpz: ... - def lcm(self, other: ifmpz, /) -> fmpz: ... - def factor(self, trial_limit: int | None = None) -> list[tuple[fmpz, int]]: ... - def factor_smooth(self, bits: int = 15, proved: int = -1) -> list[tuple[fmpz, int]]: ... - - def is_prime(self) -> bool: ... - def is_probable_prime(self) -> bool: ... - def is_square(self) -> bool: ... - def is_perfect_power(self) -> bool: ... - - def partitions_p(self) -> fmpz: ... - def moebius_mu(self) -> fmpz: ... - def fac_ui(self) -> fmpz: ... - def primorial_ui(self) -> fmpz: ... - def fib_ui(self) -> fmpz: ... - def rising(self, n: int) -> fmpz: ... - - @classmethod - def bin_uiui(cls, n: int, k: int) -> fmpz: ... - @classmethod - def bell_number(cls, n: int) -> fmpz: ... - @classmethod - def euler_number(cls, n: int) -> fmpz: ... - @classmethod - def stirling_s1(cls, n: int, k: int) -> fmpz: ... - @classmethod - def stirling_s2(cls, n: int, k: int) -> fmpz: ... - - def divisor_sigma(self, k: int) -> fmpz: ... - def euler_phi(self) -> fmpz: ... - - def isqrt(self) -> fmpz: ... - def sqrt(self) -> fmpz: ... - def sqrtrem(self) -> tuple[fmpz, fmpz]: ... - def sqrtmod(self, p: ifmpz) -> fmpz: ... - def root(self, n: int) -> fmpz: ... - - def jacobi(self, other: ifmpz, /) -> int: ... diff --git a/src/flint/types/fmpz.pyx b/src/flint/types/fmpz.pyx deleted file mode 100644 index 390282aa..00000000 --- a/src/flint/types/fmpz.pyx +++ /dev/null @@ -1,1026 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.utils.typecheck cimport typecheck -from flint.utils.conversion cimport chars_from_str -from flint.utils.conversion cimport str_from_chars, _str_trunc -from libc.stdlib cimport malloc, free - -from flint.flintlib.types.flint cimport FMPZ_REF, FMPZ_TMP, FMPZ_UNKNOWN, COEFF_IS_MPZ -from flint.flintlib.functions.flint cimport flint_free -from flint.flintlib.functions.fmpz cimport * -from flint.flintlib.types.fmpz cimport fmpz_factor_expand -from flint.flintlib.functions.fmpz_factor cimport * -from flint.flintlib.functions.arith cimport * -from flint.flintlib.functions.partitions cimport * - -from flint.utils.flint_exceptions import DomainError - -cdef fmpz_get_intlong(fmpz_t x): - """ - Convert fmpz_t to a Python int or long. - """ - cdef slong size - cdef ulong * words - cdef int i - cdef fmpz_struct xabs[1] - if COEFF_IS_MPZ(x[0]): - # Python from signed bytes is slow so we convert the absolute value. - # we need 8 * sizeof(ulong) * size >= fmpz_bits(x) - size = fmpz_bits(x) // (8 * sizeof(ulong)) + 1 - words = malloc(size * sizeof(ulong)) - if fmpz_sgn(x) == -1: - fmpz_init(xabs) - fmpz_abs(xabs, x) - fmpz_get_ui_array(words, size, xabs) - fmpz_clear(xabs) - else: - fmpz_get_ui_array(words, size, x) - if is_big_endian: - for i in range(size): - words[i] = ulong_from_little_endian((words + i)) - v = int.from_bytes((words)[:size * sizeof(ulong)], "little") - if fmpz_sgn(x) == -1: - v = -v - free(words) - return v - else: - return x[0] - -cdef int fmpz_set_any_ref(fmpz_t x, obj): - if typecheck(obj, fmpz): - x[0] = (obj).val[0] - return FMPZ_REF - if PyLong_Check(obj): - fmpz_init(x) - fmpz_set_pylong(x, obj) - return FMPZ_TMP - return FMPZ_UNKNOWN - -cdef any_as_fmpz(obj): - cdef fmpz_struct x[1] - cdef bint xtype - cdef fmpz v - xtype = fmpz_set_any_ref(x, obj) - if xtype == FMPZ_REF: - v = fmpz.__new__(fmpz) - fmpz_set(v.val, x) - return v - elif xtype == FMPZ_TMP: - v = fmpz.__new__(fmpz) - fmpz_clear(v.val) - v.val[0] = x[0] - return v - else: - return NotImplemented - -cdef class fmpz(flint_scalar): - """ - The *fmpz* type represents an arbitrary-size integer. - - >>> fmpz(3) ** 25 - 847288609443 - - """ - - def __cinit__(self): - fmpz_init(self.val) - - def __dealloc__(self): - fmpz_clear(self.val) - - def __init__(self, *args): - if not args: - return - elif len(args) != 1: - raise TypeError("fmpz takes zero or one arguments.") - val = args[0] - if typecheck(val, fmpz): - fmpz_set(self.val, (val).val) - else: - if fmpz_set_any_ref(self.val, val) == FMPZ_UNKNOWN: # XXX - if typecheck(val, str): - if fmpz_set_str(self.val, chars_from_str(val), 10) != 0: - raise ValueError("invalid string for fmpz") - return - raise TypeError("cannot create fmpz from type %s" % type(val)) - - @property - def numerator(self): - return self - - @property - def denominator(self): - return fmpz(1) - - def __reduce__(self): - return (fmpz, (int(self),)) - - # XXX: improve! - def __int__(self): - return fmpz_get_intlong(self.val) - - def __index__(self): - return fmpz_get_intlong(self.val) - - def __float__(self): - return float(fmpz_get_intlong(self.val)) - - def __floor__(self): - return self - - def __ceil__(self): - return self - - def __trunc__(self): - return self - - def __round__(self, ndigits=None): - if ndigits is None: - return self - else: - return fmpz(round(int(self), ndigits)) - - def __richcmp__(s, t, int op): - cdef bint res = 0 - cdef fmpz_struct tval[1] - cdef fmpz_struct * sval - cdef int ttype - sval = &((s).val[0]) - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if op == 2: - res = fmpz_equal(sval, tval) - elif op == 3: - res = not fmpz_equal(sval, tval) - elif op == 0: - res = fmpz_cmp(sval, tval) < 0 - elif op == 1: - res = fmpz_cmp(sval, tval) <= 0 - elif op == 4: - res = fmpz_cmp(sval, tval) > 0 - elif op == 5: - res = fmpz_cmp(sval, tval) >= 0 - if ttype == FMPZ_TMP: - fmpz_clear(tval) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - return res - - def bit_length(self): - return fmpz_bits(self.val) - - def str(self, int base=10, long condense=0): - """ - Converts *self* to a string, optionally in a non-decimal base - and optionally showing only leading and trailing digits. - - >>> (fmpz(3) ** 100).str() - '515377520732011331036461129765621272702107522001' - >>> (fmpz(3) ** 100).str(base=3, condense=10) - '1000000000{...81 digits...}0000000000' - """ - assert 2 <= base <= 36 - cdef char * s = fmpz_get_str(NULL, base, self.val) - try: - res = str_from_chars(s) - finally: - flint_free(s) - if condense > 0: - res = _str_trunc(res, condense) - return res - - def repr(self): - return "fmpz(%s)" % self.str() - - def __bool__(self): - return not fmpz_is_zero(self.val) - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpz res = fmpz.__new__(fmpz) - fmpz_neg(res.val, self.val) - return res - - def __abs__(self): - if fmpz_sgn(self.val) >= 0: - return self - return -self - - def __add__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - u = fmpz.__new__(fmpz) - fmpz_add((u).val, (s).val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __radd__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - u = fmpz.__new__(fmpz) - fmpz_add((u).val, tval, (s).val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __sub__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - u = fmpz.__new__(fmpz) - fmpz_sub((u).val, (s).val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rsub__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - u = fmpz.__new__(fmpz) - fmpz_sub((u).val, tval, (s).val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __mul__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - u = fmpz.__new__(fmpz) - fmpz_mul((u).val, (s).val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rmul__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - u = fmpz.__new__(fmpz) - fmpz_mul((u).val, tval, (s).val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __truediv__(s, t): - cdef fmpz_struct tval[1] - cdef fmpz_struct rval[1] - cdef int ttype - - ttype = fmpz_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - - if fmpz_is_zero(tval): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - - q = fmpz.__new__(fmpz) - fmpz_init(rval) - fmpz_fdiv_qr((q).val, rval, (s).val, tval) - exact = fmpz_is_zero(rval) - fmpz_clear(rval) - - if ttype == FMPZ_TMP: - fmpz_clear(tval) - - if exact: - return q - else: - raise DomainError("fmpz division is not exact") - - def __rtruediv__(s, t): - t = any_as_fmpz(t) - if t is NotImplemented: - return t - return t.__truediv__(s) - - def __floordiv__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if fmpz_is_zero(tval): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - u = fmpz.__new__(fmpz) - fmpz_fdiv_q((u).val, (s).val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rfloordiv__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if fmpz_is_zero((s).val): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - u = fmpz.__new__(fmpz) - fmpz_fdiv_q((u).val, tval, (s).val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __mod__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if fmpz_is_zero(tval): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - u = fmpz.__new__(fmpz) - fmpz_fdiv_r((u).val, (s).val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rmod__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if fmpz_is_zero((s).val): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - u = fmpz.__new__(fmpz) - fmpz_fdiv_r((u).val, tval, (s).val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __divmod__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if fmpz_is_zero(tval): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - u1 = fmpz.__new__(fmpz) - u2 = fmpz.__new__(fmpz) - fmpz_fdiv_qr((u1).val, (u2).val, (s).val, tval) - u = u1, u2 - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rdivmod__(s, t): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - u = NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype != FMPZ_UNKNOWN: - if fmpz_is_zero((s).val): - if ttype == FMPZ_TMP: - fmpz_clear(tval) - raise ZeroDivisionError("fmpz division by zero") - u1 = fmpz.__new__(fmpz) - u2 = fmpz.__new__(fmpz) - fmpz_fdiv_qr((u1).val, (u2).val, tval, (s).val) - u = u1, u2 - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __pow__(s, t, m): - cdef fmpz_struct sval[1] - cdef fmpz_struct tval[1] - cdef fmpz_struct mval[1] - cdef int stype = FMPZ_UNKNOWN - cdef int ttype = FMPZ_UNKNOWN - cdef int mtype = FMPZ_UNKNOWN - cdef int success - u = NotImplemented - - try: - stype = fmpz_set_any_ref(sval, s) - if stype == FMPZ_UNKNOWN: - return NotImplemented - ttype = fmpz_set_any_ref(tval, t) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - if m is None: - # fmpz_pow_fmpz throws if x is negative - if fmpz_sgn(tval) == -1: - raise ValueError("negative exponent") - - u = fmpz.__new__(fmpz) - success = fmpz_pow_fmpz((u).val, (s).val, tval) - - if not success: - raise OverflowError("fmpz_pow_fmpz: exponent too large") - - return u - else: - # Modular exponentiation - mtype = fmpz_set_any_ref(mval, m) - if mtype == FMPZ_UNKNOWN: - return NotImplemented - - if fmpz_is_zero(mval): - raise ValueError("pow(): modulus cannot be zero") - - # The Flint docs say that fmpz_powm will throw if m is zero - # but it also throws if m is negative. Python generally allows - # e.g. pow(2, 2, -3) == (2^2) % (-3) == -2. We could implement - # that here as well but it is not clear how useful it is. - if fmpz_sgn(mval) == -1: - raise ValueError("pow(): negative modulus not supported") - - u = fmpz.__new__(fmpz) - fmpz_powm((u).val, sval, tval, mval) - - return u - finally: - if stype == FMPZ_TMP: - fmpz_clear(sval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - if mtype == FMPZ_TMP: - fmpz_clear(mval) - - def __rpow__(s, t, m): - t = any_as_fmpz(t) - if t is NotImplemented: - return t - return t.__pow__(s, m) - - def __lshift__(self, other): - if typecheck(other, fmpz): - other = int(other) - if typecheck(other, int): - if other < 0: - raise ValueError("negative shift count") - u = fmpz.__new__(fmpz) - fmpz_mul_2exp((u).val, self.val, other) - return u - else: - return NotImplemented - - def __rlshift__(self, other): - iself = int(self) - if iself < 0: - raise ValueError("negative shift count") - if typecheck(other, int): - u = fmpz.__new__(fmpz) - fmpz_mul_2exp((u).val, fmpz(other).val, iself) - return u - else: - return NotImplemented - - def __rshift__(self, other): - if typecheck(other, fmpz): - other = int(other) - if typecheck(other, int): - if other < 0: - raise ValueError("negative shift count") - u = fmpz.__new__(fmpz) - fmpz_fdiv_q_2exp((u).val, self.val, other) - return u - else: - return NotImplemented - - def __rrshift__(self, other): - iself = int(self) - if iself < 0: - raise ValueError("negative shift count") - if typecheck(other, int): - u = fmpz.__new__(fmpz) - fmpz_fdiv_q_2exp((u).val, fmpz(other).val, iself) - return u - else: - return NotImplemented - - def __and__(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = fmpz.__new__(fmpz) - fmpz_and((u).val, self.val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rand__(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = fmpz.__new__(fmpz) - fmpz_and((u).val, tval, self.val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __or__(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = fmpz.__new__(fmpz) - fmpz_or((u).val, self.val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __ror__(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = fmpz.__new__(fmpz) - fmpz_or((u).val, tval, self.val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __xor__(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = fmpz.__new__(fmpz) - fmpz_xor((u).val, self.val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __rxor__(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - return NotImplemented - u = fmpz.__new__(fmpz) - fmpz_xor((u).val, tval, self.val) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def __invert__(self): - u = fmpz.__new__(fmpz) - fmpz_complement((u).val, self.val) - return u - - def gcd(self, other): - """ - Returns the greatest common divisor of self and other. - - >>> fmpz(30).gcd(45) - 15 - """ - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - raise TypeError("input must be an integer") - u = fmpz.__new__(fmpz) - fmpz_gcd((u).val, self.val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def lcm(self, other): - """ - Returns the greatest common divisor of self and other. - - >>> fmpz(30).gcd(45) - 15 - """ - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - raise TypeError("input must be an integer") - u = fmpz.__new__(fmpz) - fmpz_lcm((u).val, self.val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return u - - def factor(self, trial_limit=None): - """ - Factors self into prime numbers, returning a list of - (prime, exp) pairs. The sign is ignored. - - >>> fmpz(5040).factor() - [(2, 4), (3, 2), (5, 1), (7, 1)] - >>> fmpz(10**35 + 1).factor() - [(11, 1), (9091, 1), (909091, 1), (4147571, 1), (265212793249617641, 1)] - >>> len(fmpz.fac_ui(1000).factor()) - 168 - - Warning: factoring large integers can be slow unless all - prime factors are small. - - If *trial_limit* is set, perform trial division with at most - this many primes, returning an incomplete factorization in which - the largest factor may be composite. Factors largers than the trial - division limit may still be found if it is cheap to do so, but no - expensive algorithms will be run. - - >>> fmpz(2**128+10).factor() - [(2, 1), (7, 1), (23, 1), (677, 1), (2957, 1), (1042733, 1), (506256324715258822390969, 1)] - >>> fmpz(2**128+10).factor(trial_limit=200) - [(2, 1), (7, 1), (23, 1), (677, 1), (1560971251139657345905734136865089, 1)] - """ - cdef fmpz_factor_t fac - cdef fmpz_t tmp - cdef int i - fmpz_factor_init(fac) - if trial_limit is not None: - fmpz_factor_trial_range(fac, self.val, 0, trial_limit) - fmpz_init(tmp) - fmpz_factor_expand(tmp, fac) - fmpz_divexact(tmp, self.val, tmp) - fmpz_abs(tmp, tmp) - if not fmpz_is_one(tmp): - _fmpz_factor_append(fac, tmp, 1) - fmpz_clear(tmp) - else: - fmpz_factor(fac, self.val) - res = [0] * fac.num - for 0 <= i < fac.num: - u = fmpz.__new__(fmpz) - fmpz_set((u).val, &fac.p[i]) - exp = fac.exp[i] - res[i] = (u, exp) - fmpz_factor_clear(fac) - return res - - def factor_smooth(self, bits=15, int proved=-1): - cdef fmpz_factor_t fac - cdef int i - fmpz_factor_init(fac) - fmpz_factor_smooth(fac, self.val, bits, proved) - res = [0] * fac.num - for 0 <= i < fac.num: - u = fmpz.__new__(fmpz) - fmpz_set((u).val, &fac.p[i]) - exp = fac.exp[i] - res[i] = (u, exp) - fmpz_factor_clear(fac) - return res - - def is_prime(self): - return fmpz_is_prime(self.val) - - def is_probable_prime(self): - return fmpz_is_probabprime(self.val) - - def is_perfect_power(self): - r""" - Return ``True`` if this integer is of the form `r^k` with `k>1`, False otherwise. - `0, 1, -1` are considered perfect powers. - - >>> fmpz(81).is_perfect_power() - True - >>> fmpz(1234).is_perfect_power() - False - """ - cdef int k - cdef fmpz v = fmpz() - k = fmpz_is_perfect_power(v.val, self.val) - return k != 0 - - def is_square(self): - r""" - Return True if perfect square and False otherwise. - - >>> fmpz(25).is_square() - True - >>> fmpz(101).is_square() - False - """ - return fmpz_is_square(self.val) != 0 - - def partitions_p(n): - r""" - Returns `p(n)`, the number of partitions of `n`, as an *fmpz*. - - >>> [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 - - The partition function grows rapidly. - On a 32-bit system, `n` must not be larger than about `10^{16}`. - On a 64-bit system, `n` must not be larger than about `10^{20}`. - For large `n`, this function benefits from setting ``ctx.threads = 2`` - on multicore systems. - """ - cdef fmpz v = fmpz() - partitions_fmpz_fmpz(v.val, n.val, 0) - return v - - def moebius_mu(n): - r""" - Returns the Moebius function `\mu(n)` as an *fmpz*. - - >>> [fmpz(n).moebius_mu() for n in range(10)] - [0, 1, -1, -1, 0, -1, 1, -1, 0, 0] - """ - cdef fmpz v = fmpz() - fmpz_set_si(v.val, fmpz_moebius_mu(n.val)) - return v - - @classmethod - def fac_ui(cls, ulong n): - r""" - Returns the factorial `n!` as an *fmpz*. - - >>> fmpz.fac_ui(10) - 3628800 - """ - u = fmpz.__new__(fmpz) - fmpz_fac_ui((u).val, n) - return u - - @classmethod - def primorial_ui(cls, ulong n): - r""" - Returns the product of all primes less than or equal to *n* - (*n* primorial) as an *fmpz*. - - >>> fmpz.primorial_ui(10) - 210 - """ - u = fmpz.__new__(fmpz) - fmpz_primorial((u).val, n) - return u - - @classmethod - def fib_ui(cls, ulong n): - r""" - Returns the Fibonacci number `F_n` as an *fmpz*. - - >>> fmpz.fib_ui(10) - 55 - """ - u = fmpz.__new__(fmpz) - fmpz_fib_ui((u).val, n) - return u - - def rising(s, ulong n): - r""" - Returns the rising factorial `s (s+1) \cdots (s+n-1)` as an *fmpz*. - - >>> fmpz(10).rising(5) - 240240 - """ - u = fmpz.__new__(fmpz) - fmpz_rfac_ui((u).val, (s).val, n) - return u - - @classmethod - def bin_uiui(cls, ulong n, ulong k): - r""" - Returns the binomial coefficient `{n \choose k}` as an *fmpz*. - """ - u = fmpz.__new__(fmpz) - fmpz_bin_uiui((u).val, n, k) - return u - - @classmethod - def bell_number(cls, ulong n): - r""" - Returns the Bell number `B_n` as an *fmpz*. - - >>> fmpz.bell_number(10) - 115975 - """ - u = fmpz.__new__(fmpz) - arith_bell_number((u).val, n) - return u - - @classmethod - def euler_number(cls, ulong n): - r""" - Returns the Euler number `E_n` as an *fmpz*. - - >>> fmpz.euler_number(10) - -50521 - """ - u = fmpz.__new__(fmpz) - arith_euler_number((u).val, n) - return u - - @classmethod - def stirling_s1(cls, ulong n, ulong k): - r""" - Returns the Stirling number of the first kind `S_1(n,k)` as an *fmpz*. - - >>> fmpz.stirling_s1(10,5) - -269325 - """ - u = fmpz.__new__(fmpz) - arith_stirling_number_1((u).val, n, k) - return u - - @classmethod - def stirling_s2(cls, ulong n, ulong k): - r""" - Returns the Stirling number of the second kind `S_2(n,k)` as an *fmpz*. - - >>> fmpz.stirling_s2(10,5) - 42525 - """ - u = fmpz.__new__(fmpz) - arith_stirling_number_2((u).val, n, k) - return u - - def divisor_sigma(n, k): - r""" - Returns the divisor sum `\sigma_k(n)` as an *fmpz*. - - >>> fmpz(60).divisor_sigma(0) - 12 - >>> fmpz(60).divisor_sigma(1) - 168 - >>> fmpz(60).divisor_sigma(10) - 605263138639095300 - """ - cdef fmpz v = fmpz() - fmpz_divisor_sigma(v.val, k, n.val) - return v - - def euler_phi(n): - r""" - Returns the Euler totient function `\varphi(n)` as an *fmpz*. - - >>> fmpz(60).euler_phi() - 16 - >>> fmpz(3**10).euler_phi() - 39366 - """ - cdef fmpz v = fmpz() - fmpz_euler_phi(v.val, n.val) - return v - - def __hash__(self): - return hash(int(self)) - - def height_bits(self, bint signed=False): - if signed and fmpz_sgn(self.val) < 0: - return -self.bit_length() - else: - return self.bit_length() - - def isqrt(self): - """ - Return square root rounded down. - - >>> fmpz(9).isqrt() - 3 - >>> fmpz(8).isqrt() - 2 - - """ - cdef fmpz v - - if fmpz_sgn(self.val) < 0: - raise DomainError("integer square root of a negative number") - - v = fmpz() - fmpz_sqrt(v.val, self.val) - return v - - def sqrt(self): - """ - Return exact integer square root of self or raise an error. - - >>> fmpz(9).sqrt() - 3 - >>> fmpz(8).sqrt() - Traceback (most recent call last): - ... - flint.utils.flint_exceptions.DomainError: not a square number - - """ - cdef fmpz v - - if fmpz_sgn(self.val) < 0: - raise DomainError("integer square root of a negative number") - - v = fmpz() - fmpz_sqrt(v.val, self.val) - - c = fmpz() - fmpz_mul(c.val, v.val, v.val) - if not fmpz_equal(c.val, self.val): - raise DomainError("not a square number") - - return v - - def sqrtrem(self): - """ - Return the integer square root of self and remainder. - - >>> fmpz(9).sqrtrem() - (3, 0) - >>> fmpz(8).sqrtrem() - (2, 4) - >>> c = fmpz(123456789012345678901234567890) - >>> u, v = c.sqrtrem() - >>> u ** 2 + v == c - True - - """ - cdef fmpz u, v - - if fmpz_sgn(self.val) < 0: - raise DomainError("integer square root of a negative number") - - u = fmpz() - v = fmpz() - fmpz_sqrtrem(u.val, v.val, self.val) - - return u, v - - # warning: m should be prime! - def sqrtmod(self, p): - """ - Return modular square root of self modulo *p* or raise an error. - - >>> fmpz(10).sqrtmod(13) - 6 - >>> (6**2) % 13 - 10 - >>> fmpz(11).sqrtmod(13) - Traceback (most recent call last): - ... - flint.utils.flint_exceptions.DomainError: modular square root does not exist - - The modulus *p* must be a prime number. - """ - cdef fmpz v - - v = fmpz() - if fmpz_is_zero(self.val): - return v - - p = fmpz(p) - if not fmpz_sqrtmod(v.val, self.val, (p).val): - raise DomainError("modular square root does not exist") - - return v - - def root(self, long n): - cdef fmpz v - if fmpz_sgn(self.val) < 0: - raise ValueError("integer root of a negative number") - if n <= 0: - raise ValueError("n >= 1 is required") - v = fmpz() - fmpz_root(v.val, self.val, n) - return v - - def jacobi(self, other): - cdef fmpz_struct tval[1] - cdef int ttype = FMPZ_UNKNOWN - ttype = fmpz_set_any_ref(tval, other) - if ttype == FMPZ_UNKNOWN: - raise TypeError("input must be an integer") - v = fmpz_jacobi(self.val, tval) - if ttype == FMPZ_TMP: - fmpz_clear(tval) - return fmpz(v) diff --git a/src/flint/types/fmpz_mat.pxd b/src/flint/types/fmpz_mat.pxd deleted file mode 100644 index c8cca24f..00000000 --- a/src/flint/types/fmpz_mat.pxd +++ /dev/null @@ -1,11 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat -from flint.flintlib.functions.fmpz_mat cimport fmpz_mat_t -from flint.types.fmpz cimport fmpz -cdef any_as_fmpz_mat(obj) - -cdef class fmpz_mat(flint_mat): - - cdef fmpz_mat_t val - cpdef long nrows(self) - cpdef long ncols(self) - cdef __mul_fmpz(self, fmpz c) diff --git a/src/flint/types/fmpz_mat.pyx b/src/flint/types/fmpz_mat.pyx deleted file mode 100644 index d2d9f3b6..00000000 --- a/src/flint/types/fmpz_mat.pyx +++ /dev/null @@ -1,970 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat -from flint.utils.typecheck cimport typecheck -from flint.types.fmpz cimport fmpz -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq_mat cimport fmpq_mat -from flint.types.fmpz cimport any_as_fmpz -from flint.pyflint cimport global_random_state -from flint.types.fmpq cimport any_as_fmpq -cimport cython -cimport libc.stdlib - -from flint.flintlib.types.flint cimport SIZEOF_SLONG - -from flint.flintlib.functions.fmpz cimport ( - fmpz_set, - fmpz_init, - fmpz_clear, - fmpz_set_si, - fmpz_mul, - fmpz_equal, - fmpz_equal_si, -) -from flint.flintlib.functions.fmpz cimport fmpz_is_zero, fmpz_is_pm1 -from flint.flintlib.types.fmpz cimport ( - fmpz_mat_struct, - rep_type, - gram_type, -) -from flint.flintlib.functions.fmpz_poly cimport fmpz_poly_init -from flint.flintlib.functions.fmpz_mat cimport * -from flint.flintlib.functions.fmpz_lll cimport * -from flint.flintlib.functions.fmpq_mat cimport fmpq_mat_init -from flint.flintlib.functions.fmpq_mat cimport fmpq_mat_set_fmpz_mat_div_fmpz -from flint.flintlib.functions.fmpq_mat cimport fmpq_mat_solve_fmpz_mat - -from flint.utils.flint_exceptions import DomainError - - -cdef any_as_fmpz_mat(obj): - if typecheck(obj, fmpz_mat): - return obj - return NotImplemented - -cdef class fmpz_mat(flint_mat): - """ - The *fmpz_mat* type represents dense matrices over the integers. - - An *fmpz_mat* can be constructed empty, from a list of entries in - row-major order, from a list of lists, or from an existing matrix:: - - >>> fmpz_mat(2, 4) - [0, 0, 0, 0] - [0, 0, 0, 0] - >>> A = fmpz_mat(2, 4, range(8)) - >>> A - [0, 1, 2, 3] - [4, 5, 6, 7] - >>> fmpz_mat(A) == A - True - >>> fmpz_mat([[1,2,3],[4,5,6]]) - [1, 2, 3] - [4, 5, 6] - - Entries can be accessed and set:: - - >>> A[0,1] - 1 - >>> A[1,3] = 8 - >>> A - [0, 1, 2, 3] - [4, 5, 6, 8] - - Arithmetic operations are supported:: - - >>> A * 3 - [ 0, 3, 6, 9] - [12, 15, 18, 24] - >>> A + (-A) - [0, 0, 0, 0] - [0, 0, 0, 0] - >>> A * fmpz_mat(4, 3, range(12)) - [ 42, 48, 54] - [123, 146, 169] - >>> A * fmpz_mat(3, 3, range(9)) - Traceback (most recent call last): - ... - ValueError: incompatible shapes for matrix multiplication - - Disabling pretty-printing:: - - >>> from flint import ctx - >>> ctx.pretty = False - >>> fmpz_mat([[1,2,3],[4,5,6]]) - fmpz_mat(2, 3, [1, 2, 3, 4, 5, 6]) - >>> ctx.pretty = True - - """ - - # cdef fmpz_mat_t val - - def __cinit__(self): - fmpz_mat_init(self.val, 0, 0) - - def __dealloc__(self): - fmpz_mat_clear(self.val) - - @cython.embedsignature(False) - def __init__(self, *args): - cdef long m, n, i, j - if len(args) == 1: - val = args[0] - if typecheck(val, fmpz_mat): - fmpz_mat_init_set(self.val, (val).val) - elif isinstance(val, (list, tuple)): - m = len(val) - n = 0 - if m != 0: - if not isinstance(val[0], (list, tuple)): - raise TypeError("single input to fmpz_mat must be a list of lists") - n = len(val[0]) - for i from 1 <= i < m: - if len(val[i]) != n: - raise ValueError("input rows have different lengths") - fmpz_mat_init(self.val, m, n) - for i from 0 <= i < m: - row = val[i] - for j from 0 <= j < n: - x = fmpz(row[j]) - fmpz_set(fmpz_mat_entry(self.val, i, j), (x).val) - else: - raise TypeError("cannot create fmpz_mat from input of type %s" % type(val)) - elif len(args) == 2: - m, n = args - fmpz_mat_init(self.val, m, n) - elif len(args) == 3: - m, n, entries = args - fmpz_mat_init(self.val, m, n) - entries = list(entries) - if len(entries) != m*n: - raise ValueError("list of entries has the wrong length") - for i from 0 <= i < m: - for j from 0 <= j < n: - # XXX: slow - x = fmpz(entries[i*n + j]) - fmpz_set(fmpz_mat_entry(self.val, i, j), (x).val) - else: - raise TypeError("fmpz_mat: expected 1-3 arguments") - - def __bool__(self): - return not fmpz_mat_is_zero(self.val) - - def __richcmp__(fmpz_mat s, t, int op): - cdef bint r - if op != 2 and op != 3: - raise TypeError("matrices cannot be ordered") - t = any_as_fmpz_mat(t) - if t is NotImplemented: - return t - r = fmpz_mat_equal((s).val, (t).val) - if op == 3: - r = not r - return r - - cpdef long nrows(self): - """ - Returns the number of rows of self. - """ - return fmpz_mat_nrows(self.val) - - cpdef long ncols(self): - """ - Returns the number of columns of *self*. - """ - return fmpz_mat_ncols(self.val) - - def __getitem__(self, index): - cdef long i, j - cdef fmpz x - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - x = fmpz.__new__(fmpz) - fmpz_set(x.val, fmpz_mat_entry(self.val, i, j)) - return x - - def __setitem__(self, index, value): - cdef long i, j - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - c = fmpz(value) # XXX - fmpz_set(fmpz_mat_entry(self.val, i, j), (c).val) - - def det(self): - """ - Returns the determinant of *self* as an *fmpz*. - - >>> A = fmpz_mat(3, 3, range(9)) - >>> A.det() - 0 - >>> A[2,2] = 10 - >>> A.det() - -6 - >>> (A * A).det() - 36 - >>> fmpz_mat(0, 0).det() - 1 - - """ - cdef fmpz d - if not fmpz_mat_is_square(self.val): - raise ValueError("matrix must be square") - d = fmpz.__new__(fmpz) - fmpz_mat_det(d.val, self.val) - return d - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpz_mat t = fmpz_mat(self) - fmpz_mat_neg(t.val, t.val) # XXX - return t - - def __add__(s, t): - cdef fmpz_mat u - cdef fmpz_mat_struct *sval - cdef fmpz_mat_struct *tval - tm = any_as_fmpz_mat(t) - if tm is NotImplemented: - return tm - sval = &(s).val[0] - tval = &(t).val[0] - if (fmpz_mat_nrows(sval) != fmpz_mat_nrows(tval) or - fmpz_mat_ncols(sval) != fmpz_mat_ncols(tval)): - raise ValueError("incompatible shapes for matrix addition") - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_nrows(sval), fmpz_mat_ncols(sval)) - fmpz_mat_add(u.val, sval, tval) - return u - - def __sub__(s, t): - cdef fmpz_mat u - cdef fmpz_mat_struct *sval - cdef fmpz_mat_struct *tval - tm = any_as_fmpz_mat(t) - if tm is NotImplemented: - return tm - sval = &(s).val[0] - tval = &(t).val[0] - if (fmpz_mat_nrows(sval) != fmpz_mat_nrows(tval) or - fmpz_mat_ncols(sval) != fmpz_mat_ncols(tval)): - raise ValueError("incompatible shapes for matrix subtraction") - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_nrows(sval), fmpz_mat_ncols(sval)) - fmpz_mat_sub(u.val, sval, tval) - return u - - cdef __mul_fmpz(self, fmpz c): - cdef fmpz_mat u - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_nrows(self.val), fmpz_mat_ncols(self.val)) - fmpz_mat_scalar_mul_fmpz(u.val, self.val, c.val) - return u - - def __mul__(s, t): - cdef fmpz_mat u - cdef fmpz_mat_struct *sval - cdef fmpz_mat_struct *tval - if typecheck(t, fmpz_mat): - sval = &(s).val[0] - tval = &(t).val[0] - if fmpz_mat_ncols(sval) != fmpz_mat_nrows(tval): - raise ValueError("incompatible shapes for matrix multiplication") - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_nrows(sval), fmpz_mat_ncols(tval)) - fmpz_mat_mul(u.val, sval, tval) - return u - else: - c = any_as_fmpz(t) - if c is not NotImplemented: - return (s).__mul_fmpz(c) - c = any_as_fmpq(t) - if c is not NotImplemented: - # XXX: improve this - return fmpq_mat(s) * t - return NotImplemented - - def __rmul__(s, t): - c = any_as_fmpz(t) - if c is not NotImplemented: - return (s).__mul_fmpz(c) - c = any_as_fmpq(t) - if c is not NotImplemented: - # XXX: improve this - return fmpq_mat(s) * t - return NotImplemented - - def __truediv__(fmpz_mat s, t): - cdef fmpz_mat u - cdef fmpz_mat_struct *sval - t = any_as_fmpz(t) - if t is NotImplemented: - return t - if fmpz_is_zero((t).val): - raise ZeroDivisionError("division by zero") - sval = &(s).val[0] - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_nrows(sval), fmpz_mat_ncols(sval)) - fmpz_mat_scalar_divexact_fmpz(u.val, sval, (t).val) - # XXX: check for exact division - there should be a better way! - if u * t != s: - raise DomainError("fmpz_mat division is not exact") - return u - - def __pow__(self, e, m): - cdef fmpz_mat t - cdef ulong ee - if not typecheck(self, fmpz_mat): - return NotImplemented - if not fmpz_mat_is_square((self).val): - raise ValueError("matrix must be square") - if m is not None: - raise NotImplementedError("modular matrix exponentiation") - ee = e - t = fmpz_mat(self) # XXX - fmpz_mat_pow(t.val, t.val, ee) - return t - - def is_square(self): - """Return whether *self* is a square *NxN* matrix.""" - return bool(fmpz_mat_is_square(self.val)) - - def is_empty(self): - """Return whether *self* is an empty *0xN* or *Nx0* matrix.""" - return bool(fmpz_mat_is_empty(self.val)) - - def is_zero(self): - """Return whether *self* is a zero matrix.""" - return bool(fmpz_mat_is_zero(self.val)) - - def is_one(self): - """Return whether *self* is the identity matrix.""" - return bool(fmpz_mat_is_one(self.val)) - - def is_neg_one(self): - """Return whether *self* is the negative identity matrix.""" - if not self.is_square(): - return False - elif not self.is_scalar(): - return False - elif self.is_empty(): - return True - else: - return bool(fmpz_equal_si(fmpz_mat_entry(self.val, 0, 0), -1)) - - def is_upper_triangular(self): - """Return whether *self* is an upper triangular matrix.""" - for i in range(1, fmpz_mat_nrows(self.val)): - for j in range(min(i, fmpz_mat_ncols(self.val))): - if not fmpz_is_zero(fmpz_mat_entry(self.val, i, j)): - return False - return True - - def is_lower_triangular(self): - """Return whether *self* is a lower triangular matrix.""" - for i in range(fmpz_mat_nrows(self.val)): - for j in range(i + 1, fmpz_mat_ncols(self.val)): - if not fmpz_is_zero(fmpz_mat_entry(self.val, i, j)): - return False - return True - - def is_diagonal(self): - """Return whether *self* is a diagonal matrix.""" - return self.is_upper_triangular() and self.is_lower_triangular() - - def is_scalar(self): - """Return whether *self* is a scalar multiple of the identity matrix.""" - if not (self.is_square() and self.is_diagonal()): - return False - for i in range(fmpz_mat_nrows(self.val)): - if not fmpz_equal(fmpz_mat_entry(self.val, i, i), fmpz_mat_entry(self.val, 0, 0)): - return False - return True - - @classmethod - def hadamard(cls, ulong n): - """ - Attempts to construct a Hadamard matrix of size *n*. - Raises :exc:`ValueError` if no such Hadamard matrix exists. - The method can also raise :exc:`ValueError` if it fails to - construct a Hadamard matrix of the specified size, even if one exists. - It always succeeds if *n* is a power of two. - - >>> fmpz_mat.hadamard(1) - [1] - >>> fmpz_mat.hadamard(2) - [1, 1] - [1, -1] - >>> fmpz_mat.hadamard(4) - [1, 1, 1, 1] - [1, -1, 1, -1] - [1, 1, -1, -1] - [1, -1, -1, 1] - >>> fmpz_mat.hadamard(12) - [ 1, -1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1] - [-1, -1, 1, -1, 1, -1, 1, -1, 1, -1, 1, -1] - [ 1, 1, 1, -1, 1, 1, -1, -1, -1, -1, 1, 1] - [ 1, -1, -1, -1, 1, -1, -1, 1, -1, 1, 1, -1] - [ 1, 1, 1, 1, 1, -1, 1, 1, -1, -1, -1, -1] - [ 1, -1, 1, -1, -1, -1, 1, -1, -1, 1, -1, 1] - [ 1, 1, -1, -1, 1, 1, 1, -1, 1, 1, -1, -1] - [ 1, -1, -1, 1, 1, -1, -1, -1, 1, -1, -1, 1] - [ 1, 1, -1, -1, -1, -1, 1, 1, 1, -1, 1, 1] - [ 1, -1, -1, 1, -1, 1, 1, -1, -1, -1, 1, -1] - [ 1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, -1] - [ 1, -1, 1, -1, -1, 1, -1, 1, 1, -1, -1, -1] - >>> fmpz_mat.hadamard(10) - Traceback (most recent call last): - ... - ValueError: unable to construct Hadamard matrix of size 10 - - """ - cdef fmpz_mat res = fmpz_mat(n, n) - if fmpz_mat_hadamard(res.val): - return res - else: - raise ValueError("unable to construct Hadamard matrix of size %i" % n) - - def is_hadamard(self): - """ - Determines whether *self* is a Hadamard matrix. - - >>> (fmpz_mat.hadamard(20) * -1).is_hadamard() - True - >>> (fmpz_mat.hadamard(20) * 2).is_hadamard() - False - """ - return bool(fmpz_mat_is_hadamard(self.val)) - - @classmethod - def randtest(cls, ulong m, ulong n, ulong bits): - """ - Returns a random (*m*, *n*) matrix with non-uniformly chosen - entries up to the specified number of bits in size. Small and - zero entries are generated with increased probability. - - >>> fmpz_mat.randtest(3, 2, 100) # doctest: +SKIP - [ 5442103460568216, 1906839377153448] - [-37778931862922801979391, 0] - [ 0, 1] - - """ - cdef fmpz_mat mat = fmpz_mat(m, n) - fmpz_mat_randtest(mat.val, global_random_state, bits) - return mat - - @classmethod - def randbits(cls, ulong m, ulong n, ulong bits): - """ - Returns a random (*m*, *n*) matrix with uniformly chosen entries up - to the specified number of bits in size. - - >>> fmpz_mat.randbits(3, 2, 100) # doctest: +SKIP - [ 502804798116524380422349115480, -93136769489619409388141424916] - [-1201505897735399116254292047234, 145439343004100224514654363320] - [ 1183889243483733739229662952032, 632771515833349927306121868518] - - """ - cdef fmpz_mat mat = fmpz_mat(m, n) - fmpz_mat_randbits(mat.val, global_random_state, bits) - return mat - - @classmethod - def randrank(cls, ulong m, ulong n, ulong rank, ulong bits): - """ - Returns a random sparse (*m*, *n*) matrix of the specified rank - with entries up to the specified number of bits in size. - - >>> fmpz_mat.randrank(3,6,2,20) # doctest: +SKIP - [0, 484749, 0, 0, 0, 0] - [0, 0, 0, 0, 0, 0] - [0, 0, 0, 0, 0, -2048] - - """ - cdef fmpz_mat mat - if rank > m or rank > n: - raise ValueError("impossible rank") - mat = fmpz_mat(m, n) - fmpz_mat_randrank(mat.val, global_random_state, rank, bits) - return mat - - def rank(self): - """ - Returns the rank of *self*. - - >>> A = fmpz_mat(3, 3, range(9)) - >>> A.rank() - 2 - >>> A[2,2] = 10 - >>> A.rank() - 3 - """ - return fmpz_mat_rank(self.val) - - def inv(self, bint integer=False): - """ - Returns the inverse matrix of *self*, which by default will - be of type *fmpq_mat*:: - - >>> fmpz_mat(3,3,[1,2,4,0,1,1,2,-1,0]).inv() - [-1/3, 4/3, 2/3] - [-2/3, 8/3, 1/3] - [ 2/3, -5/3, -1/3] - - If *integer* is set, returns the inverse as an *fmpz_mat*, - or raises an exception if the matrix is not invertible - over the integers. - - >>> fmpz_mat([[5,1],[19,4]]).inv(integer=True) - [ 4, -1] - [-19, 5] - >>> fmpz_mat([[5,1],[19,5]]).inv(integer=True) - Traceback (most recent call last): - ... - ValueError: matrix is not invertible over the integers - - """ - cdef fmpz_mat_t tmp - cdef fmpz_mat v - cdef fmpq_mat u - cdef fmpz_t den - if not fmpz_mat_is_square(self.val): - raise ValueError("matrix must be square") - fmpz_mat_init_set(tmp, self.val) - fmpz_init(den) - try: - fmpz_mat_inv(tmp, den, self.val) - if fmpz_is_zero(den): - raise ZeroDivisionError("matrix is singular") - if integer: - if not fmpz_is_pm1(den): - raise ValueError("matrix is not invertible over the integers") - v = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init_set(v.val, tmp) - return v - else: - u = fmpq_mat.__new__(fmpq_mat) - fmpq_mat_init(u.val, fmpz_mat_nrows(self.val), fmpz_mat_ncols(self.val)) - fmpq_mat_set_fmpz_mat_div_fmpz(u.val, tmp, den) - return u - finally: - fmpz_clear(den) - fmpz_mat_clear(tmp) - - def transpose(self): - """ - Returns the transpose of *self*. - - >>> fmpz_mat(2,3,range(6)).transpose() - [0, 3] - [1, 4] - [2, 5] - """ - cdef fmpz_mat u - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_ncols(self.val), fmpz_mat_nrows(self.val)) - fmpz_mat_transpose(u.val, self.val) - return u - - def solve(self, other, bint integer=False): - """ - Given matrices *A* and *B* represented by *self* and *other*, - returns an *fmpq_mat* *X* such that `AX = B`, assuming that - *A* is square and invertible. - - If *integer* is *True*, returns an *fmpz_mat*, solving the - system only if the system matrix is invertible over the integers. - (Warning: solving with *integer* set to *True* is - currently slow for large matrices.) - - >>> A = fmpz_mat(2, 2, [1,4,8,3]) - >>> B = fmpz_mat(2, 3, range(6)) - >>> A.solve(B) - [12/29, 13/29, 14/29] - [-3/29, 4/29, 11/29] - >>> A.solve(B, integer=True) - Traceback (most recent call last): - ... - ValueError: matrix is not invertible over the integers - >>> fmpz_mat([[1,2], [3,5]]).solve(B, integer=True) - [ 6, 3, 0] - [-3, -1, 1] - >>> fmpz_mat(2, 2, [1,0,2,0]).solve(B) - Traceback (most recent call last): - ... - ZeroDivisionError: singular matrix in solve() - >>> A.solve(fmpz_mat(1, 2, [2,3])) - Traceback (most recent call last): - ... - ValueError: need a square system and compatible right hand side - - """ - cdef fmpz_mat u - cdef fmpq_mat v - cdef fmpz d - cdef int result - t = any_as_fmpz_mat(other) - if t is NotImplemented: - raise TypeError("cannot convert input to fmpz_mat") - if (fmpz_mat_nrows(self.val) != fmpz_mat_ncols(self.val) or - fmpz_mat_nrows(self.val) != fmpz_mat_nrows((t).val)): - raise ValueError("need a square system and compatible right hand side") - if not integer: - v = fmpq_mat(fmpz_mat_nrows((t).val), fmpz_mat_ncols((t).val)) - result = fmpq_mat_solve_fmpz_mat(v.val, self.val, (t).val) - if not result: - raise ZeroDivisionError("singular matrix in solve()") - return v - else: - u = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(u.val, fmpz_mat_nrows((t).val), - fmpz_mat_ncols((t).val)) - d = fmpz.__new__(fmpz) - result = fmpz_mat_solve(u.val, d.val, self.val, (t).val) - if not fmpz_is_pm1(d.val): - raise ValueError("matrix is not invertible over the integers") - u *= d - if not result: - raise ZeroDivisionError("singular matrix in solve()") - return u - - def _fflu(self): - """ - Fraction-free LU decomposition of *self*. - - >>> A = fmpz_mat([[1, 2], [3, 4]]) - >>> LU, d, perm, rank = A._fflu() - >>> LU - [1, 2] - [3, -2] - >>> d - -2 - >>> perm - [0, 1] - >>> rank - 2 - - The matrix *LU* is the LU contains both the lower and upper parts of - the decomposition. The integer *d* is the divisor and is up to a sign - the determinant when *self* is square. The list *perm* is the - permutation of the rows of *self*. - - This is the raw output from the underlying FLINT function fmpz_mat_fflu. - The method :meth:`fflu` provides a more understandable representation - of the decomposition. - - """ - cdef fmpz d - cdef slong* perm - cdef slong r, c, rank - cdef fmpz_mat LU - r = fmpz_mat_nrows(self.val) - c = fmpz_mat_ncols(self.val) - perm = libc.stdlib.malloc(r * SIZEOF_SLONG) - if perm is NULL: - raise MemoryError("malloc failed") - try: - for i in range(r): - perm[i] = i - LU = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init((LU).val, r, c) - d = fmpz.__new__(fmpz) - rank = fmpz_mat_fflu(LU.val, d.val, perm, self.val, 0) - perm_int = [] - for i in range(r): - perm_int.append(perm[i]) - finally: - libc.stdlib.free(perm) - - return LU, d, perm_int, rank - - def fflu(self): - """ - Fraction-free LU decomposition of *self*. - - Returns a tuple (*P*, *L*, *D*, *U*) representing the the fraction-free - LU decomposition of a matrix *A* as - - P*A = L*inv(D)*U - - where *P* is a permutation matrix, *L* is lower triangular, *D* is - diagonal and *U* is upper triangular. - - >>> A = fmpz_mat([[1, 2], [3, 4]]) - >>> P, L, D, U = A.fflu() - >>> P - [1, 0] - [0, 1] - >>> L - [1, 0] - [3, -2] - >>> D - [1, 0] - [0, -2] - >>> U - [1, 2] - [0, -2] - >>> P*A == L*D.inv()*U - True - - This method works for matrices of any shape and rank. - - """ - cdef slong r, c - cdef slong i, j, k, l - cdef fmpz di - cdef fmpz_mat P, L, U, D - r = fmpz_mat_nrows(self.val) - c = fmpz_mat_ncols(self.val) - - U, _d, perm, _rank = self._fflu() - - P = fmpz_mat(r, r) - for i, pi in enumerate(perm): - fmpz_set_si(fmpz_mat_entry(P.val, i, pi), 1) - - L = fmpz_mat(r, r) - - i = j = k = 0 - while i < r and j < c: - if not fmpz_is_zero(fmpz_mat_entry(U.val, i, j)): - fmpz_set(fmpz_mat_entry(L.val, i, k), fmpz_mat_entry(U.val, i, j)) - for l in range(i + 1, r): - fmpz_set(fmpz_mat_entry(L.val, l, k), fmpz_mat_entry(U.val, l, j)) - fmpz_set_si(fmpz_mat_entry(U.val, l, j), 0) - i += 1 - k += 1 - j += 1 - - for k in range(k, r): - fmpz_set_si(fmpz_mat_entry(L.val, k, k), 1) - - D = fmpz_mat(r, r) - - if r >= 1: - fmpz_set(fmpz_mat_entry(D.val, 0, 0), fmpz_mat_entry(L.val, 0, 0)) - di = fmpz(1) - for i in range(1, r): - fmpz_mul(di.val, fmpz_mat_entry(L.val, i-1, i-1), fmpz_mat_entry(L.val, i, i)) - fmpz_set(fmpz_mat_entry(D.val, i, i), di.val) - - return P, L, D, U - - def rref(self, inplace=False): - """ - Computes the reduced row echelon form (rref) of *self*, - either returning a new copy or modifying self in-place. - Returns (*rref*, *denominator*, *rank*). - - >>> from flint import ctx - >>> ctx.pretty = False - >>> A = fmpz_mat(3,3,range(9)) - >>> A.rref() - (fmpz_mat(3, 3, [3, 0, -3, 0, 3, 6, 0, 0, 0]), fmpz(3), 2) - >>> A.rref(inplace=True) - (fmpz_mat(3, 3, [3, 0, -3, 0, 3, 6, 0, 0, 0]), fmpz(3), 2) - >>> A - fmpz_mat(3, 3, [3, 0, -3, 0, 3, 6, 0, 0, 0]) - >>> ctx.pretty = True - - """ - cdef fmpz d - if inplace: - res = self - else: - res = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init((res).val, fmpz_mat_nrows(self.val), fmpz_mat_ncols(self.val)) - d = fmpz.__new__(fmpz) - rank = fmpz_mat_rref((res).val, d.val, self.val) - return res, d, rank - - def nullspace(self): - """ - Computes a basis for the nullspace of the matrix *A* represented - by *self*. Returns (*X*, *nullity*) where nullity is the rank of - the nullspace of *A* and *X* is a matrix whose first *nullity* - columns are linearly independent, and such that `AX = 0`. - - >>> A = fmpz_mat(3,5,range(1,16)) - >>> X, nullity = A.nullspace() - >>> A.rank(), nullity, X.rank() - (2, 3, 3) - >>> A * X - [0, 0, 0, 0, 0] - [0, 0, 0, 0, 0] - [0, 0, 0, 0, 0] - >>> X - [ 5, 10, 15, 0, 0] - [-10, -15, -20, 0, 0] - [ 5, 0, 0, 0, 0] - [ 0, 5, 0, 0, 0] - [ 0, 0, 5, 0, 0] - - """ - cdef fmpz_mat res - res = fmpz_mat.__new__(fmpz_mat) - fmpz_mat_init(res.val, fmpz_mat_ncols(self.val), fmpz_mat_ncols(self.val)) - nullity = fmpz_mat_nullspace(res.val, self.val) - return res, nullity - - def lll(self, bint transform=False, double delta=0.99, double eta=0.51, rep="zbasis", gram="approx"): - r""" - Returns the LLL reduction of *self*, optionally along with - a transformation matrix. - - >>> M = fmpz_mat([[11,17],[13,19]]) - >>> M.lll() - [ 2, 2] - [-3, 3] - >>> L, T = M.lll(transform=True) - >>> T * M == L - True - - """ - cdef fmpz_mat u, v - cdef fmpz_lll_t ctx - cdef long i - cdef rep_type rt - cdef gram_type gt - if rep == "zbasis": - rt = rep_type.Z_BASIS - elif rep == "gram": - rt = rep_type.GRAM - else: - raise ValueError("rep must be 'zbasis' or 'gram'") - if gram == "approx": - gt = gram_type.APPROX - elif gram == "exact": - gt = gram_type.EXACT - else: - raise ValueError("gram must be 'approx' or 'exact'") - fmpz_lll_context_init(ctx, delta, eta, rt, gt) - u = fmpz_mat(self) - - # FLINT would segfault given a matrix with zero rows - if u.nrows() == 0: - if transform: - v = fmpz_mat(0, 0, []) - return u, v - else: - return u - - if transform: - v = fmpz_mat(self.nrows(), self.nrows()) - for 0 <= i < self.nrows(): - v[i, i] = 1 - fmpz_lll(u.val, v.val, ctx) - return u, v - else: - fmpz_lll(u.val, NULL, ctx) - return u - - def hnf(self, bint transform=False): - """ - Returns the Hermite normal form of *self*, optionally - with a transformation matrix. - - >>> A = fmpz_mat(3,4,range(12)) - >>> A.hnf() - [4, 0, -4, -8] - [0, 1, 2, 3] - [0, 0, 0, 0] - >>> H, T = A.hnf(transform=True) - >>> H == T * A - True - """ - cdef fmpz_mat H - cdef fmpz_mat U - H = fmpz_mat(self.nrows(), self.ncols()) - if transform: - U = fmpz_mat(self.nrows(), self.nrows()) - fmpz_mat_hnf_transform(H.val, U.val, self.val) - return H, U - else: - fmpz_mat_hnf(H.val, self.val) - return H - - def is_hnf(self): - """ - Determines whether *self* is in Hermite normal form. - - >>> fmpz_mat(3,4,range(12)).is_hnf() - False - >>> fmpz_mat(3,4,range(12)).hnf().is_hnf() - True - """ - return bool(fmpz_mat_is_in_hnf(self.val)) - - def snf(self): - """ - Returns the Smith normal form of *self*. - - >>> A = fmpz_mat(3,4,range(12)) - >>> A.snf() - [1, 0, 0, 0] - [0, 4, 0, 0] - [0, 0, 0, 0] - """ - cdef fmpz_mat H - H = fmpz_mat(self.nrows(), self.ncols()) - fmpz_mat_snf(H.val, self.val) - return H - - def is_snf(self): - """ - Determines whether *self* is in Smith normal form. - - >>> fmpz_mat(3,4,range(12)).is_snf() - False - >>> fmpz_mat(3,4,range(12)).snf().is_snf() - True - """ - return bool(fmpz_mat_is_in_snf(self.val)) - - def charpoly(self): - """Returns the characteristic polynomial of *self* as an *fmpz_poly*. - - >>> from flint import fmpz_mat - >>> A = fmpz_mat(3, 3, range(9)) - >>> A - [0, 1, 2] - [3, 4, 5] - [6, 7, 8] - >>> A.charpoly() - x^3 + (-12)*x^2 + (-18)*x - """ - cdef fmpz_poly u - - if not fmpz_mat_is_square(self.val): - raise ValueError("matrix must be square") - - u = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_init(u.val) - fmpz_mat_charpoly(u.val, self.val) - return u - - def minpoly(self): - """Returns the minimal polynomial of *self* as an *fmpz_poly*. - - >>> from flint import fmpz_mat - >>> A = fmpz_mat([[2, 1, 0], [0, 2, 0], [0, 0, 2]]) - >>> A - [2, 1, 0] - [0, 2, 0] - [0, 0, 2] - >>> A.charpoly() - x^3 + (-6)*x^2 + 12*x + (-8) - >>> A.minpoly() - x^2 + (-4)*x + 4 - """ - cdef fmpz_poly u - - if not fmpz_mat_is_square(self.val): - raise ValueError("matrix must be square") - - u = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_init(u.val) - fmpz_mat_minpoly(u.val, self.val) - return u diff --git a/src/flint/types/fmpz_mod.pxd b/src/flint/types/fmpz_mod.pxd deleted file mode 100644 index 9de08b3c..00000000 --- a/src/flint/types/fmpz_mod.pxd +++ /dev/null @@ -1,21 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.flintlib.functions.fmpz cimport fmpz_struct, fmpz_t -from flint.flintlib.functions.fmpz_mod cimport ( - fmpz_mod_ctx_t, - fmpz_mod_discrete_log_pohlig_hellman_t -) - -cdef class fmpz_mod_ctx: - cdef fmpz_mod_ctx_t val - cdef bint _is_prime - cdef bint _init_L - cdef fmpz_mod_discrete_log_pohlig_hellman_t L - - cdef set_any_as_fmpz_mod(self, fmpz_t val, obj) - cdef any_as_fmpz_mod(self, obj) - cdef discrete_log_pohlig_hellman_run(self, fmpz_t x, fmpz_t y) - -cdef class fmpz_mod(flint_scalar): - cdef fmpz_mod_ctx ctx - cdef fmpz_t val - cdef fmpz_t x_g diff --git a/src/flint/types/fmpz_mod.pyi b/src/flint/types/fmpz_mod.pyi deleted file mode 100644 index 23f07e6e..00000000 --- a/src/flint/types/fmpz_mod.pyi +++ /dev/null @@ -1,66 +0,0 @@ -from ..flint_base.flint_base import flint_scalar -from .fmpz import fmpz -from .fmpq import fmpq - - -ifmpz = int | fmpz -ifmpq = int | fmpz | fmpq -ifmpz_mod = ifmpz | fmpz_mod - - -class fmpz_mod_ctx: - - def __init__(self, mod: ifmpz) -> None: ... - def modulus(self) -> fmpz: ... - def is_prime(self) -> bool: ... - def zero(self) -> fmpz_mod: ... - def one(self) -> fmpz_mod: ... - def random_element(self) -> fmpz_mod: ... - def __eq__(self, other: object) -> bool: ... - def __hash__(self) -> int: ... - def __str__(self) -> str: ... - def __repr__(self) -> str: ... - def __call__(self, val: ifmpz_mod) -> fmpz_mod: ... - - -class fmpz_mod(flint_scalar): - - def __init__(self, val: ifmpz_mod, mod: fmpz_mod_ctx) -> None: ... - - def is_zero(self) -> bool: ... - - - def is_one(self) -> bool: ... - def is_unit(self) -> bool: ... - - def inverse(self, check: bool = True) -> fmpz_mod: ... - - def discrete_log(self, a: ifmpz_mod) -> fmpz: ... - - def __eq__(self, other: object) -> bool: ... - def __ne__(self, other: object) -> bool: ... - - def __bool__(self) -> bool: ... - - def repr(self) -> str: ... - def __repr__(self) -> str: ... - def __str__(self) -> str: ... - def __int__(self) -> int: ... - def str(self) -> str: ... - - def __pos__(self) -> fmpz_mod: ... - - def __neg__(self) -> fmpz_mod: ... - - def __add__(self, other: ifmpz_mod, /) -> fmpz_mod: ... - def __radd__(self, other: ifmpq, /) -> fmpz_mod: ... - def __sub__(self, other: ifmpz_mod, /) -> fmpz_mod: ... - def __rsub__(self, other: ifmpq, /) -> fmpz_mod: ... - def __mul__(self, other: ifmpz_mod, /) -> fmpz_mod: ... - def __rmul__(self, other: ifmpq, /) -> fmpz_mod: ... - def __truediv__(self, other: ifmpz_mod, /) -> fmpz_mod: ... - def __rtruediv__(self, other: ifmpq, /) -> fmpz_mod: ... - def __pow__(self, other: ifmpz, /) -> fmpz_mod: ... - def __invert__(self) -> fmpz_mod: ... - - def sqrt(self) -> fmpz_mod: ... diff --git a/src/flint/types/fmpz_mod.pyx b/src/flint/types/fmpz_mod.pyx deleted file mode 100644 index f838b931..00000000 --- a/src/flint/types/fmpz_mod.pyx +++ /dev/null @@ -1,608 +0,0 @@ -from flint.pyflint cimport global_random_state -from flint.flintlib.functions.fmpz cimport( - fmpz_t, - fmpz_one, - fmpz_zero, - fmpz_set, - fmpz_init, - fmpz_clear, - fmpz_equal, - fmpz_is_probabprime, - fmpz_mul, - fmpz_invmod, - fmpz_sqrtmod, - fmpz_divexact, - fmpz_gcd, - fmpz_is_one, - fmpz_is_zero, - fmpz_randm -) -from flint.flintlib.functions.fmpz cimport fmpz_mod as fmpz_type_mod -from flint.flintlib.functions.fmpz_mod cimport * - -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_base cimport flint_scalar -from flint.types.fmpz cimport( - fmpz, - any_as_fmpz, - fmpz_get_intlong -) -cimport libc.stdlib - -from flint.utils.flint_exceptions import DomainError - - -cdef class fmpz_mod_ctx: - r""" - Context object for creating :class:`~.fmpz_mod` initialised - with a modulus :math:`N`. - - >>> fmpz_mod_ctx(2**127 - 1) - fmpz_mod_ctx(170141183460469231731687303715884105727) - - """ - def __cinit__(self): - cdef fmpz one = fmpz.__new__(fmpz) - fmpz_one(one.val) - fmpz_mod_ctx_init(self.val, one.val) - fmpz_mod_discrete_log_pohlig_hellman_init(self.L) - self._is_prime = 0 - - def __dealloc__(self): - fmpz_mod_ctx_clear(self.val) - fmpz_mod_discrete_log_pohlig_hellman_clear(self.L) - - def __init__(self, mod): - # Ensure modulus is fmpz type - if not typecheck(mod, fmpz): - mod = any_as_fmpz(mod) - if mod is NotImplemented: - raise TypeError( - "Context modulus must be able to be cast to an `fmpz` type" - ) - - # Ensure modulus is positive - if mod < 1: - raise ValueError("Modulus is expected to be positive") - - # Set the modulus - fmpz_mod_ctx_set_modulus(self.val, (mod).val) - - # Check whether the modulus is prime - # TODO: should we use a stronger test? - self._is_prime = fmpz_is_probabprime(self.val.n) - - def modulus(self): - """ - Return the modulus from the context as an fmpz - type - - >>> mod_ctx = fmpz_mod_ctx(2**127 - 1) - >>> mod_ctx.modulus() - 170141183460469231731687303715884105727 - - """ - n = fmpz() - fmpz_set(n.val, (self.val.n)) - return n - - def is_prime(self): - """ - Return whether the modulus is prime - - >>> fmpz_mod_ctx(2**127).is_prime() - False - >>> fmpz_mod_ctx(2**127 - 1).is_prime() - True - """ - return self._is_prime == 1 - - def zero(self): - """ - Return the zero element - - >>> F = fmpz_mod_ctx(163) - >>> F.zero() - fmpz_mod(0, 163) - """ - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - fmpz_zero(res.val) - res.ctx = self - - return res - - def one(self): - """ - Return the one element - - >>> F = fmpz_mod_ctx(163) - >>> F.one() - fmpz_mod(1, 163) - """ - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - fmpz_one(res.val) - res.ctx = self - - return res - - def random_element(self): - r""" - Return a random element in :math:`\mathbb{Z}/N\mathbb{Z}` - """ - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self - - fmpz_randm(res.val, global_random_state, self.val.n) - - return res - - cdef discrete_log_pohlig_hellman_run(self, fmpz_t x, fmpz_t y): - # First, Ensure that L has performed precomputations This generates a - # base which is a primitive root, and used as the base in - # fmpz_mod_discrete_log_pohlig_hellman_run - if not self._init_L: - fmpz_mod_discrete_log_pohlig_hellman_precompute_prime(self.L, self.val.n) - self._init_L = True - - fmpz_mod_discrete_log_pohlig_hellman_run(x, self.L, y) - - cdef set_any_as_fmpz_mod(self, fmpz_t val, obj): - # Try and convert obj to fmpz - if typecheck(obj, fmpz_mod): - if self != (obj).ctx: - raise ValueError("moduli must match") - fmpz_set(val, (obj).val) - return 0 - - # Try and convert obj to fmpz - if not typecheck(obj, fmpz): - obj = any_as_fmpz(obj) - if obj is NotImplemented: - return NotImplemented - - fmpz_mod_set_fmpz(val, (obj).val, self.val) - - return 0 - - cdef any_as_fmpz_mod(self, obj): - # If `obj` is an `fmpz_mod`, just check moduli - # match - if typecheck(obj, fmpz_mod): - if self != (obj).ctx: - raise ValueError("moduli must match") - return obj - - # We have been able to cast `obj` to an `fmpz` so - # we create a new `fmpz_mod` and set the val - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - check = self.set_any_as_fmpz_mod(res.val, obj) - if check is NotImplemented: - return NotImplemented - res.ctx = self - - return res - - def __eq__(self, other): - # TODO: - # If we could cache contexts, then we would ensure that only - # the a is b check is needed for equality. - - # Most often, we expect both `fmpz_mod` to be pointing to the - # same ctx, so this seems the fastest way to check - if self is other: - return True - - # If they're not the same object in memory, they may have the - # same modulus, which is good enough - if typecheck(other, fmpz_mod_ctx): - return fmpz_equal(self.val.n, (other).val.n) == 1 - return False - - def __hash__(self): - return hash(self.modulus()) - - def __str__(self): - return f"Context for fmpz_mod with modulus: {self.modulus()}" - - def __repr__(self): - return f"fmpz_mod_ctx({self.modulus()})" - - def __call__(self, val): - return fmpz_mod(val, self) - -cdef class fmpz_mod(flint_scalar): - """ - The *fmpz_mod* type represents integer modulo an - arbitrary-size modulus. For wordsize modulus, see - :class:`~.nmod`. - - An *fmpz_mod* element is constructed from an :class:`~.fmpz_mod_ctx` - either by passing it as an argument to the type, or - by directly calling the context - - >>> fmpz_mod(-1, fmpz_mod_ctx(2**127 - 1)) - fmpz_mod(170141183460469231731687303715884105726, 170141183460469231731687303715884105727) - >>> ZmodN = fmpz_mod_ctx(2**127 - 1) - >>> ZmodN(-2) - fmpz_mod(170141183460469231731687303715884105725, 170141183460469231731687303715884105727) - - """ - - def __cinit__(self): - fmpz_init(self.val) - fmpz_init(self.x_g) - - def __dealloc__(self): - fmpz_clear(self.val) - fmpz_clear(self.x_g) - - def __init__(self, val, ctx): - if not typecheck(ctx, fmpz_mod_ctx): - raise TypeError - self.ctx = ctx - check = self.ctx.set_any_as_fmpz_mod(self.val, val) - if check is NotImplemented: - raise NotImplementedError(f"Cannot convert {val} to type 'fmpz_mod'") - - def is_zero(self): - """ - Return whether an element is equal to zero - - >>> mod_ctx = fmpz_mod_ctx(163) - >>> mod_ctx(0).is_zero() - True - >>> mod_ctx(1).is_zero() - False - """ - return self == 0 - - def is_one(self): - """ - Return whether an element is equal to one - - >>> mod_ctx = fmpz_mod_ctx(163) - >>> mod_ctx(0).is_one() - False - >>> mod_ctx(1).is_one() - True - """ - - cdef bint res - res = fmpz_mod_is_one(self.val, self.ctx.val) - return res == 1 - - def is_unit(self): - """ - Returns whether the element is invertible modulo `N` - - >>> from flint import * - >>> F = fmpz_mod_ctx(10) - >>> F(3).is_unit() - True - >>> F(2).is_unit() - False - """ - cdef fmpz_t g - fmpz_init(g) - fmpz_gcd(g, self.val, self.ctx.val.n) - return 1 == fmpz_is_one(g) - - def inverse(self, check=True): - r""" - Computes :math:`a^{-1} \pmod N` - - When check=False, the solutions is assumed to exist and Flint will abort on - failure. - - >>> mod_ctx = fmpz_mod_ctx(163) - >>> mod_ctx(2).inverse() - fmpz_mod(82, 163) - >>> mod_ctx(2).inverse(check=False) - fmpz_mod(82, 163) - """ - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx - - if check is False: - fmpz_mod_inv(res.val, self.val, self.ctx.val) - return res - - cdef bint r - cdef fmpz one = fmpz.__new__(fmpz) - fmpz_one(one.val) - - r = fmpz_mod_divides( - res.val, one.val, self.val, self.ctx.val - ) - if r == 0: - raise ZeroDivisionError( - f"{self} is not invertible modulo {self.ctx.modulus()}" - ) - - return res - - def discrete_log(self, a): - r""" - Solve the discrete logarithm problem, using `self = g` as a base. - Assumes a solution, :math:`a = g^x \pmod p` exists. - - NOTE: Requires that the context modulus is prime. - - >>> F = fmpz_mod_ctx(163) - >>> g = F(2) - >>> x = 123 - >>> a = g**123 - >>> g.discrete_log(a) - 123 - """ - # Ensure that the modulus is prime - if not self.ctx.is_prime(): - raise NotImplementedError("algorithm assumes modulus is prime") - - # Then check the type of the input - a = self.ctx.any_as_fmpz_mod(a) - if a is NotImplemented: - raise TypeError(f"Cannot solve the discrete log with {type(a)} as input") - - # Solve the discrete log for the chosen base and target - # g = y^x_g and a = y^x_a - # We want to find x such that a = g^x => - # (y^x_a) = (y^x_g)^x => x = (x_a / x_g) mod (p-1) - - # For repeated calls to discrete_log, it's more efficient to - # store x_g rather than keep computing it - if fmpz_is_zero(self.x_g): - self.ctx.discrete_log_pohlig_hellman_run(self.x_g, self.val) - - # Then we need to compute x_a which will be different for each call - cdef fmpz_t x_a - fmpz_init(x_a) - self.ctx.discrete_log_pohlig_hellman_run(x_a, (a).val) - - # If g is not a primitive root, then x_g and pm1 will share - # a common factor. We can use this to compute the order of - # g. - cdef fmpz_t g, g_order, x_g - fmpz_init(g) - fmpz_init(g_order) - fmpz_init(x_g) - - fmpz_gcd(g, self.x_g, self.ctx.L.pm1) - if not fmpz_is_one(g): - fmpz_divexact(x_g, self.x_g, g) - fmpz_divexact(x_a, x_a, g) - fmpz_divexact(g_order, self.ctx.L.pm1, g) - else: - fmpz_set(g_order, self.ctx.L.pm1) - fmpz_set(x_g, self.x_g) - - # Finally, compute output exponent by computing - # (x_a / x_g) mod g_order - cdef fmpz x = fmpz.__new__(fmpz) - fmpz_invmod(x.val, x_g, g_order) - fmpz_mul(x.val, x.val, x_a) - fmpz_type_mod(x.val, x.val, g_order) - - return x - - def __richcmp__(self, other, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("fmpz_mod cannot be ordered") - - other = self.ctx.any_as_fmpz_mod(other) - if other is NotImplemented: - return NotImplemented - - res = fmpz_equal(self.val, (other).val) and \ - (self.ctx == (other).ctx) - return res if op == 2 else not res - - def __bool__(self): - return not self.is_zero() - - def repr(self): - return "fmpz_mod({}, {})".format( - fmpz_get_intlong(self.val), - self.ctx.modulus() - ) - - def __repr__(self): - return self.repr() - - def __hash__(self): - return hash((int(self))) - - def __int__(self): - return fmpz_get_intlong(self.val) - - def str(self): - return str(int(self)) - - def __str__(self): - return self.str() - - # ---------------- # - # Arithmetic # - # ---------------- # - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx - fmpz_mod_neg(res.val, self.val, self.ctx.val) - return res - - def __add__(self, other): - other = self.ctx.any_as_fmpz_mod(other) - if other is NotImplemented: - return NotImplemented - - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx - fmpz_mod_add( - res.val, self.val, (other).val, self.ctx.val - ) - return res - - def __radd__(self, other): - return self.__add__(other) - - @staticmethod - def _sub_(left, right): - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - - # Case when left and right are already fmpz_mod - if typecheck(left, fmpz_mod) and typecheck(right, fmpz_mod): - if not (left).ctx == (right).ctx: - raise ValueError("moduli must match") - - # Case when right is not fmpz_mod, try to convert to fmpz - elif typecheck(left, fmpz_mod): - right = (left).ctx.any_as_fmpz_mod(right) - if right is NotImplemented: - return NotImplemented - - # Case when left is not fmpz_mod, try to convert to fmpz - else: - left = (right).ctx.any_as_fmpz_mod(left) - if left is NotImplemented: - return NotImplemented - - res.ctx = (left).ctx - fmpz_mod_sub( - res.val, (left).val, (right).val, res.ctx.val - ) - return res - - def __sub__(s, t): - return fmpz_mod._sub_(s, t) - - def __rsub__(s, t): - return fmpz_mod._sub_(t, s) - - def __mul__(self, other): - other = self.ctx.any_as_fmpz_mod(other) - if other is NotImplemented: - return NotImplemented - - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx - - fmpz_mod_mul( - res.val, self.val, (other).val, self.ctx.val - ) - return res - - def __rmul__(self, other): - return self.__mul__(other) - - @staticmethod - def _div_(left, right): - cdef bint check - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - - # Case when left and right are already fmpz_mod - if typecheck(left, fmpz_mod) and typecheck(right, fmpz_mod): - if not (left).ctx == (right).ctx: - raise ValueError("moduli must match") - - # Case when right is not fmpz_mod, try to convert to fmpz - elif typecheck(left, fmpz_mod): - right = (left).ctx.any_as_fmpz_mod(right) - if right is NotImplemented: - return NotImplemented - - # Case when left is not fmpz_mod, try to convert to fmpz - else: - left = (right).ctx.any_as_fmpz_mod(left) - if left is NotImplemented: - return NotImplemented - - res.ctx = (left).ctx - check = fmpz_mod_divides( - res.val, (left).val, (right).val, res.ctx.val - ) - if check == 0: - raise ZeroDivisionError( - f"{right} is not invertible modulo {res.ctx.modulus()}" - ) - - return res - - def __truediv__(s, t): - return fmpz_mod._div_(s, t) - - def __rtruediv__(s, t): - return fmpz_mod._div_(t, s) - - def __floordiv__(self, other): - return NotImplemented - - def __invert__(self): - return self.inverse() - - def __pow__(self, e): - cdef bint check - cdef fmpz_mod res - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx - - # Attempt to convert exponent to fmpz - e = any_as_fmpz(e) - if e is NotImplemented: - raise TypeError("fmpz_mod.__pow__: exponent must be an integer") - - check = fmpz_mod_pow_fmpz( - res.val, self.val, (e).val, self.ctx.val - ) - - if check == 0: - raise ZeroDivisionError( - f"{self} is not invertible modulo {self.ctx.modulus()}" - ) - - return res - - def sqrt(self): - """ - Return the square root of this ``fmpz_mod`` or raise an exception. - - >>> ctx = fmpz_mod_ctx(13) - >>> s = ctx(10).sqrt() - >>> s - fmpz_mod(6, 13) - >>> s * s - fmpz_mod(10, 13) - >>> ctx(11).sqrt() - Traceback (most recent call last): - ... - flint.utils.flint_exceptions.DomainError: no square root exists for 11 mod 13 - - The modulus must be prime. - - """ - cdef fmpz_mod v - - v = fmpz_mod.__new__(fmpz_mod) - v.ctx = self.ctx - - if fmpz_is_zero(self.val): - return v - - if not fmpz_sqrtmod(v.val, self.val, self.ctx.val.n): - raise DomainError("no square root exists for {} mod {}".format(self, self.ctx.modulus())) - - return v diff --git a/src/flint/types/fmpz_mod_mat.pxd b/src/flint/types/fmpz_mod_mat.pxd deleted file mode 100644 index 7117bb67..00000000 --- a/src/flint/types/fmpz_mod_mat.pxd +++ /dev/null @@ -1,27 +0,0 @@ -from flint.flintlib.types.flint cimport slong -from flint.flintlib.functions.fmpz cimport fmpz_t -from flint.flintlib.functions.fmpz_mod_mat cimport fmpz_mod_mat_t - -from flint.flint_base.flint_base cimport flint_mat -from flint.types.fmpz_mod cimport fmpz_mod_ctx, fmpz_mod - - -cdef class fmpz_mod_mat(flint_mat): - cdef fmpz_mod_mat_t val - cdef bint _initialized - cdef fmpz_mod_ctx ctx - - cdef void _init_empty(self, slong m, slong n, list args) - cdef void _init_empty_ctx(self, slong m, slong n, fmpz_mod_ctx ctx) - cdef void _init_from_list(self, slong m, slong n, list entries, list args) - # cdef void _init_from_matrix(self, flint_mat M, list args) - cdef void _init_from_matrix(self, M, list args) - cdef fmpz_mod_ctx _parse_args(self, list args) - cdef fmpz_mod_mat _new(self, slong m, slong n, fmpz_mod_ctx ctx) - cdef fmpz_mod_mat _newlike(self) - cdef fmpz_mod_mat _copy(self) - - cpdef slong nrows(self) - cpdef slong ncols(self) - cdef fmpz_mod _getitem(self, slong i, slong j) - cdef void _setitem(self, slong i, slong j, fmpz_t e) diff --git a/src/flint/types/fmpz_mod_mat.pyx b/src/flint/types/fmpz_mod_mat.pyx deleted file mode 100644 index 91d7839f..00000000 --- a/src/flint/types/fmpz_mod_mat.pyx +++ /dev/null @@ -1,645 +0,0 @@ -from flint.utils.typecheck cimport ( - typecheck, -) -from flint.flintlib.functions.fmpz cimport ( - fmpz_struct, - fmpz_t, - fmpz_init_set, - fmpz_set, -) -from flint.flintlib.types.fmpz_mod_mat_compat cimport ( - compat_fmpz_mod_mat_init, - compat_fmpz_mod_mat_init_set, - compat_fmpz_mod_mat_clear, - compat_fmpz_mod_mat_set, - compat_fmpz_mod_mat_nrows, - compat_fmpz_mod_mat_ncols, - compat_fmpz_mod_mat_entry, - compat_fmpz_mod_mat_set_entry, - compat_fmpz_mod_mat_one, - compat_fmpz_mod_mat_equal, - compat_fmpz_mod_mat_is_zero, - compat_fmpz_mod_mat_neg, - compat_fmpz_mod_mat_add, - compat_fmpz_mod_mat_sub, - compat_fmpz_mod_mat_mul, - compat_fmpz_mod_mat_scalar_mul_fmpz, - compat_fmpz_mod_mat_inv, - compat_fmpz_mod_mat_transpose, - compat_fmpz_mod_mat_solve, - compat_fmpz_mod_mat_rref, - compat_fmpz_mod_mat_charpoly, - compat_fmpz_mod_mat_minpoly, -) - -from flint.flint_base.flint_base cimport ( - flint_mat, -) -from flint.types.fmpz cimport ( - fmpz, -) -from flint.types.fmpz_mod cimport ( - fmpz_mod_ctx, - fmpz_mod, -) -from flint.types.fmpz_mod_poly cimport ( - fmpz_mod_poly, - fmpz_mod_poly_ctx, -) -from flint.types.fmpz_mat cimport ( - fmpz_mat, -) -from flint.types.nmod_mat cimport ( - nmod_mat, -) - - -cdef any_as_fmpz_mod_mat(x): - if typecheck(x, fmpz_mod_mat): - return x - elif typecheck(x, nmod_mat): - return fmpz_mod_mat(x) - else: - return NotImplemented - - -cdef any_as_fmpz_mod_mat_ctx(x, fmpz_mod_ctx ctx): - y = any_as_fmpz_mod_mat(x) - if y is not NotImplemented: - return y - if typecheck(x, fmpz_mat): - return fmpz_mod_mat(x, ctx) - return NotImplemented - - -cdef class fmpz_mod_mat(flint_mat): - """ - The ``fmpz_mod_mat`` type represents dense matrices over ``Z/nZ`` for - arbitrary ``n`` (not necessarily word-sized unlike ``nmod_mat``). Some - operations may assume that n is a prime. - """ - def __dealloc__(self): - if self._initialized: - compat_fmpz_mod_mat_clear(self.val, self.ctx.val) - - def __init__(self, *args): - """Construct an ``fmpz_mod_mat`` matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx, fmpz_mat - >>> ctx = fmpz_mod_ctx(7) - >>> fmpz_mod_mat(2, 2, [1, 2, 3, 4], ctx) - [1, 2] - [3, 4] - >>> fmpz_mod_mat([[1, 2], [3, 4]], ctx) - [1, 2] - [3, 4] - >>> fmpz_mod_mat(2, 2, ctx) - [0, 0] - [0, 0] - >>> zmat = fmpz_mat(2, 2, [1, 2, 3, 4]) - >>> fmpz_mod_mat(zmat, ctx) - [1, 2] - [3, 4] - """ - # XXX: This logic should be moved to flint_mat. - if len(args) >= 2 and isinstance(args[0], int) and isinstance(args[1], int): - if len(args) >= 3 and isinstance(args[2], (list, tuple)): - m, n, entries, *arg = args - if len(entries) != m * n: - raise ValueError("fmpz_mod_mat: invalid number of entries") - self._init_from_list(m, n, entries, arg) - else: - m, n, *arg = args - self._init_empty(m, n, arg) - - elif (len(args) >= 1 and isinstance(args[0], (list, tuple)) - and all(isinstance(arg, (list, tuple)) for arg in args[0])): - lol, *arg = args - m = len(lol) - if m == 0: - n = 0 - entries = [] - else: - n = len(lol[0]) - if any(len(row) != n for row in lol): - raise ValueError("fmpz_mod_mat: inconsistent row lengths") - entries = [x for row in lol for x in row] - self._init_from_list(m, n, entries, arg) - - # XXX: nmod_mat is not a subclass of flint_mat (it should be) - elif len(args) >= 1 and isinstance(args[0], (flint_mat, nmod_mat)): - M, *arg = args - self._init_from_matrix(M, arg) - - else: - raise TypeError("fmpz_mod_mat: invalid arguments") - - cdef fmpz_mod_ctx _parse_args(self, list args): - """Parse the context argument.""" - if len(args) != 1: - if len(args) == 0: - raise TypeError("fmpz_mod_mat: missing modulus argument") - else: - raise TypeError("fmpz_mod_mat: too many arguments") - arg = args[0] - if not typecheck(arg, fmpz_mod_ctx): - raise TypeError("fmpz_mod_mat: invalid modulus argument") - return arg - - cdef void _init_empty_ctx(self, slong m, slong n, fmpz_mod_ctx ctx): - """Initialize an empty matrix with a given modulus context.""" - self.ctx = ctx - compat_fmpz_mod_mat_init(self.val, m, n, ctx.val) - self._initialized = True - - cdef void _init_empty(self, slong m, slong n, list args): - """Initialize an empty matrix using the constructor arguments.""" - cdef fmpz_mod_ctx ctx - ctx = self._parse_args(args) - self._init_empty_ctx(m, n, ctx) - - cdef void _init_from_list(self, slong m, slong n, list entries, list args): - """Initialize a matrix from a list of entries.""" - cdef fmpz_mod_ctx ctx - cdef fmpz_mod e - ctx = self._parse_args(args) - entries = [ctx.any_as_fmpz_mod(x) for x in entries] - - self._init_empty_ctx(m, n, ctx) - for i in range(m): - for j in range(n): - val = ctx.any_as_fmpz_mod(entries[i*n + j]) - if val is NotImplemented: - raise TypeError("fmpz_mod_mat: incompatible entries") - e = val - compat_fmpz_mod_mat_set_entry(self.val, i, j, e.val, ctx.val) - - # XXX: Should be possible to type this as flint_mat but nmod_mat is not a subclass - # cdef void _init_from_matrix(self, flint_mat M, list args): - cdef void _init_from_matrix(self, M, list args): - """Initialize from another matrix.""" - cdef fmpz_mod_ctx ctx - cdef fmpz_mod_mat N1 - - if typecheck(M, fmpz_mod_mat): - N1 = M - if args: - ctx = self._parse_args(args) - else: - ctx = N1.ctx - if N1.ctx != ctx: - raise TypeError("fmpz_mod_mat: incompatible moduli") - compat_fmpz_mod_mat_init_set(self.val, N1.val, ctx.val) - self.ctx = ctx - self._initialized = True - elif typecheck(M, fmpz_mat): - # XXX: This is inefficient. - self._init_from_list(M.nrows(), M.ncols(), M.entries(), args) - elif typecheck(M, nmod_mat): - m = M.modulus() - if args: - ctx = self._parse_args(args) - if m != ctx.modulus(): - raise TypeError("fmpz_mod_mat: incompatible moduli") - else: - ctx = fmpz_mod_ctx(m) - # XXX: This is inefficient. - entries = [int(x) for x in M.entries()] - self._init_from_list(M.nrows(), M.ncols(), entries, [ctx]) - else: - raise TypeError("fmpz_mod_mat: unrocognized matrix type") - - cdef fmpz_mod_mat _new(self, slong m, slong n, fmpz_mod_ctx ctx): - """Create an initialized matrix of given shape and context.""" - cdef fmpz_mod_mat res - res = fmpz_mod_mat.__new__(fmpz_mod_mat) - compat_fmpz_mod_mat_init(res.val, m, n, ctx.val) - res.ctx = ctx - res._initialized = True - return res - - cdef fmpz_mod_mat _newlike(self): - """Create an uninitialized matrix of the same shape and context.""" - return self._new(self.nrows(), self.ncols(), self.ctx) - - cdef fmpz_mod_mat _copy(self): - """Create a copy of the matrix.""" - cdef fmpz_mod_mat res - res = self._newlike() - compat_fmpz_mod_mat_set(res.val, self.val, self.ctx.val) - return res - - cpdef slong nrows(self): - """Return the number of rows.""" - return compat_fmpz_mod_mat_nrows(self.val, self.ctx.val) - - cpdef slong ncols(self): - """Return the number of columns.""" - return compat_fmpz_mod_mat_ncols(self.val, self.ctx.val) - - def modulus(self): - """Return the modulus.""" - cdef fmpz mod - mod = fmpz.__new__(fmpz) - fmpz_init_set(mod.val, self.ctx.val.n) - return mod - - cdef fmpz_mod _getitem(self, slong i, slong j): - """Retrieve an element as an ``fmpz_mod``.""" - cdef fmpz_struct * p_e - cdef fmpz_mod e - p_e = compat_fmpz_mod_mat_entry(self.val, i, j) - e = fmpz_mod.__new__(fmpz_mod) - fmpz_set(e.val, p_e) - e.ctx = self.ctx - return e - - cdef void _setitem(self, slong i, slong j, fmpz_t e): - """Set an element from a raw ``fmpz_t``.""" - compat_fmpz_mod_mat_set_entry(self.val, i, j, e, self.ctx.val) - - def repr(self): - """Return a representation string.""" - # XXX: Generic repr does not include modulus argument. - m = self.nrows() - n = self.ncols() - mod = self.modulus() - entries = (", ".join([x.repr() for x in self.entries()])) - return f"fmpz_mod_mat({m}, {n}, [{entries}], {mod})" - - def entries(self): - """Return a list of entries.""" - # XXX: Ideally move this to flint_mat - cdef slong i, j, m, n - m = self.nrows() - n = self.ncols() - L = [None] * (m * n) - for i from 0 <= i < m: - for j from 0 <= j < n: - L[i*n + j] = self._getitem(i, j) - return L - - def __getitem__(self, index): - """Retrieve an element.""" - # XXX: Ideally move this to flint_mat - cdef slong i, j - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - return self._getitem(i, j) - - def __setitem__(self, index, value): - """Set an element.""" - cdef slong i, j - cdef fmpz_mod e - if not (isinstance(index, tuple) and len(index) == 2): - raise TypeError("fmpz_mod_mat indices must be 2-tuples") - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - e = self.ctx.any_as_fmpz_mod(value) - self._setitem(i, j, e.val) - - def __bool__(self): - """Return ``True`` if the matrix has any nonzero entries.""" - cdef bint zero - zero = compat_fmpz_mod_mat_is_zero(self.val, self.ctx.val) - return not zero - - def __richcmp__(self, other, int op): - """Compare two matrices.""" - cdef bint res - - if op != 2 and op != 3: - raise TypeError("matrices cannot be ordered") - - other = any_as_fmpz_mod_mat_ctx(other, self.ctx) - if other is NotImplemented: - return other - - if (self).ctx != (other).ctx: - res = 0 - else: - res = compat_fmpz_mod_mat_equal((self).val, (other).val, self.ctx.val) - - if op == 2: - return res - if op == 3: - return not res - - def __pos__(self): - """``+M``: Return self (not a copy).""" - return self - - def __neg__(self): - """``-M``""" - res = self._newlike() - compat_fmpz_mod_mat_neg(( res).val, self.val, self.ctx.val) - return res - - def _as_fmpz_mod_mat(self, other, same_shape=True): - """Convert to ``fmpz_mod_mat`` but raise if shape or modulus do not match.""" - cdef fmpz_mod_mat o - other = any_as_fmpz_mod_mat_ctx(other, self.ctx) - if other is NotImplemented: - return NotImplemented - o = other - if same_shape and not (self.nrows() == o.nrows() and self.ncols() == o.ncols()): - raise ValueError("Shape mismatch: cannot add matrices") - if self.ctx != o.ctx: - raise ValueError("fmpz_mod_mat: incompatible moduli") - return o - - def _add(self, fmpz_mod_mat other): - """Add two ``fmpz_mod_mat`` matrices.""" - res = self._newlike() - compat_fmpz_mod_mat_add(res.val, self.val, other.val, self.ctx.val) - return res - - def _sub(self, fmpz_mod_mat other): - """Subtract two ``fmpz_mod_mat`` matrices.""" - res = self._newlike() - compat_fmpz_mod_mat_sub(res.val, self.val, other.val, self.ctx.val) - return res - - def _matmul(self, fmpz_mod_mat other): - """Multiply two ``fmpz_mod_mat`` matrices.""" - if self.ncols() != other.nrows(): - raise ValueError("Shape mismatch: cannot multiply matrices") - res = self._new(self.nrows(), other.ncols(), self.ctx) - compat_fmpz_mod_mat_mul(res.val, self.val, other.val, self.ctx.val) - return res - - def _scalarmul(self, fmpz_mod other): - """Multiply an ``fmpz_mod_mat`` matrix by an ``fmpz_mod`` scalar.""" - res = self._newlike() - compat_fmpz_mod_mat_scalar_mul_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - def _pow(self, slong other): - """Raise an ``fmpz_mod_mat`` matrix to an integer power.""" - cdef fmpz_mod_mat res, tmp - - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat pow: matrix must be square") - if other < 0: - self = self.inv() - other = -other - - res = self._newlike() - compat_fmpz_mod_mat_one(res.val, self.ctx.val) - - tmp = self._copy() - - while other > 0: - if other % 2 == 1: - compat_fmpz_mod_mat_mul(res.val, res.val, tmp.val, self.ctx.val) - compat_fmpz_mod_mat_mul(tmp.val, tmp.val, tmp.val, self.ctx.val) - other //= 2 - - return res - - def _div(self, fmpz_mod other): - """Divide an ``fmpz_mod_mat`` matrix by an ``fmpz_mod`` scalar.""" - return self._scalarmul(other.inverse()) - - def __add__(self, other): - """``M + N``: Add two matrices.""" - other = self._as_fmpz_mod_mat(other) - if other is NotImplemented: - return NotImplemented - return self._add(other) - - def __radd__(self, other): - """``N + M``: Add two matrices.""" - other = self._as_fmpz_mod_mat(other) - if other is NotImplemented: - return NotImplemented - return other._add(self) - - def __sub__(self, other): - """``M - N``: Subtract two matrices.""" - other = self._as_fmpz_mod_mat(other) - if other is NotImplemented: - return NotImplemented - return self._sub(other) - - def __rsub__(self, other): - """``N - M``: Subtract two matrices.""" - other = self._as_fmpz_mod_mat(other) - if other is NotImplemented: - return NotImplemented - return other._sub(self) - - def __mul__(self, other): - """``M * N``: Multiply two matrices.""" - cdef fmpz_mod e - other_mat = self._as_fmpz_mod_mat(other, same_shape=False) - if other_mat is not NotImplemented: - return self._matmul(other_mat) - other_scalar = self.ctx.any_as_fmpz_mod(other) - if other_scalar is not NotImplemented: - e = other_scalar - return self._scalarmul(e) - return NotImplemented - - def __rmul__(self, other): - """``N * M``: Multiply two matrices.""" - cdef fmpz_mod e - other_mat = self._as_fmpz_mod_mat(other) - if other_mat is not NotImplemented: - return other_mat._matmul(self) - other_scalar = self.ctx.any_as_fmpz_mod(other) - if other_scalar is not NotImplemented: - e = other_scalar - return self._scalarmul(e) - return NotImplemented - - def __pow__(self, other): - """``M ** n``: Raise a matrix to an integer power.""" - if not isinstance(other, int): - return NotImplemented - return self._pow(other) - - def __truediv__(self, other): - """``M / n``: Divide a matrix by a scalar.""" - cdef fmpz_mod e - other_scalar = self.ctx.any_as_fmpz_mod(other) - if other_scalar is not NotImplemented: - e = other_scalar - return self._div(e) - return NotImplemented - - def inv(self): - """Return the inverse of a matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[1, 2], [3, 4]], ctx) - >>> M.inv() - [5, 1] - [5, 3] - - Assumes that the modulus is prime. - """ - cdef fmpz_mod_mat res - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat inv: matrix must be square") - res = self._newlike() - r = compat_fmpz_mod_mat_inv(res.val, self.val, self.ctx.val) - if r == 0: - raise ZeroDivisionError("fmpz_mod_mat inv: matrix is not invertible") - return res - - def det(self): - """Return the determinant of a matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[1, 2], [3, 4]], ctx) - >>> M.det() - fmpz_mod(5, 7) - - """ - # XXX: No fmpz_mod_mat_det function... - p = self.charpoly() - p0 = p[0] - if self.nrows() % 2: - p0 = -p0 - return p0 - - def charpoly(self): - """Return the characteristic polynomial of a matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[1, 2], [3, 4]], ctx) - >>> M.charpoly() - x^2 + 2*x + 5 - - """ - cdef fmpz_mod_poly_ctx pctx - cdef fmpz_mod_poly res - - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat charpoly: matrix must be square") - - pctx = fmpz_mod_poly_ctx(self.ctx) - res = fmpz_mod_poly(0, pctx) - compat_fmpz_mod_mat_charpoly(res.val, self.val, self.ctx.val) - return res - - def minpoly(self): - """Return the minimal polynomial of a matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[2, 1, 0], [0, 2, 0], [0, 0, 2]], ctx) - >>> M.charpoly() - x^3 + x^2 + 5*x + 6 - >>> M.minpoly() - x^2 + 3*x + 4 - - """ - cdef fmpz_mod_poly_ctx pctx - cdef fmpz_mod_poly res - - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat minpoly: matrix must be square") - - pctx = fmpz_mod_poly_ctx(self.ctx) - res = fmpz_mod_poly(0, pctx) - compat_fmpz_mod_mat_minpoly(res.val, self.val, self.ctx.val) - return res - - def transpose(self): - """Return the transpose of a matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[1, 2], [3, 4]], ctx) - >>> M - [1, 2] - [3, 4] - >>> M.transpose() - [1, 3] - [2, 4] - """ - cdef fmpz_mod_mat res - res = self._new(self.ncols(), self.nrows(), self.ctx) - compat_fmpz_mod_mat_transpose(res.val, self.val, self.ctx.val) - return res - - def solve(self, rhs): - """Solve a linear system. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[1, 2], [3, 4]], ctx) - >>> rhs = fmpz_mod_mat([[5], [6]], ctx) - >>> M.solve(rhs) - [3] - [1] - - The matrix must be square and invertible. - - Assumes that the modulus is prime. - """ - cdef bint success - cdef fmpz_mod_mat res - - rhs = any_as_fmpz_mod_mat(rhs) - - if rhs is NotImplemented: - raise TypeError("fmpz_mod_mat solve: invalid rhs") - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat solve: matrix must be square") - if self.nrows() != rhs.nrows(): - raise ValueError("fmpz_mod_mat solve: shape mismatch") - - res = self._new(rhs.nrows(), rhs.ncols(), self.ctx) - success = compat_fmpz_mod_mat_solve(res.val, self.val, ( rhs).val, self.ctx.val) - - if not success: - raise ZeroDivisionError("Singular matrix in solve") - - return res - - def rank(self): - """Return the rank of a matrix. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(11) - >>> M = fmpz_mod_mat([[1, 2, 3], [4, 5, 6], [7, 8, 9]], ctx) - >>> M.rank() - 2 - - Assumes that the modulus is prime. - """ - return self.rref()[1] - - def rref(self, inplace=False): - """Return the reduced row echelon form of a matrix and the rank. - - >>> from flint import fmpz_mod_mat, fmpz_mod_ctx - >>> ctx = fmpz_mod_ctx(7) - >>> M = fmpz_mod_mat([[1, 2, 3], [4, 5, 6]], ctx) - >>> Mr, r = M.rref() - >>> Mr - [1, 0, 6] - [0, 1, 2] - >>> r - 2 - - If ``inplace`` is ``True``, the matrix is modified in place. - - Assumes that the modulus is prime. - """ - cdef fmpz_mod_mat res - cdef slong r - if inplace: - res = self - else: - res = self._copy() - r = compat_fmpz_mod_mat_rref(res.val, res.ctx.val) - return (res, r) diff --git a/src/flint/types/fmpz_mod_mpoly.pxd b/src/flint/types/fmpz_mod_mpoly.pxd deleted file mode 100644 index 8c473595..00000000 --- a/src/flint/types/fmpz_mod_mpoly.pxd +++ /dev/null @@ -1,36 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mpoly, flint_mod_mpoly_context - -from flint.flintlib.functions.fmpz_mod_mpoly cimport ( - fmpz_mod_mpoly_ctx_t, - fmpz_mod_mpoly_t, - fmpz_mod_mpoly_init, - fmpz_mod_mpoly_struct -) -from flint.flintlib.types.flint cimport slong - -cdef inline init_fmpz_mod_mpoly(fmpz_mod_mpoly var, fmpz_mod_mpoly_ctx ctx): - var.ctx = ctx - fmpz_mod_mpoly_init(var.val, ctx.val) - var._init = True - -cdef inline fmpz_mod_mpoly create_fmpz_mod_mpoly(fmpz_mod_mpoly_ctx ctx): - cdef fmpz_mod_mpoly var - var = fmpz_mod_mpoly.__new__(fmpz_mod_mpoly) - var.ctx = ctx - fmpz_mod_mpoly_init(var.val, ctx.val) - var._init = True - return var - -cdef class fmpz_mod_mpoly_ctx(flint_mod_mpoly_context): - cdef fmpz_mod_mpoly_ctx_t val - -cdef class fmpz_mod_mpoly(flint_mpoly): - cdef fmpz_mod_mpoly_t val - cdef fmpz_mod_mpoly_ctx ctx - cdef bint _init - -cdef class fmpz_mod_mpoly_vec: - cdef fmpz_mod_mpoly_struct *val - cdef slong length - cdef fmpz_mod_mpoly_ctx ctx - cdef fmpz_mod_mpoly_struct **double_indirect diff --git a/src/flint/types/fmpz_mod_mpoly.pyi b/src/flint/types/fmpz_mod_mpoly.pyi deleted file mode 100644 index 9f04af4f..00000000 --- a/src/flint/types/fmpz_mod_mpoly.pyi +++ /dev/null @@ -1,138 +0,0 @@ -from typing import Iterable, Mapping, Any -from ..flint_base.flint_base import ( - flint_mpoly, - flint_mpoly_context, - flint_mod_mpoly_context, - Ordering, -) -from .fmpz import fmpz -from .fmpz_mod import fmpz_mod -from .fmpz_mpoly import fmpz_mpoly - - -_str = str -ifmpz = int | fmpz -ifmpz_mod = int | fmpz | fmpz_mod - - -class fmpz_mod_mpoly_ctx(flint_mod_mpoly_context[fmpz_mod_mpoly, fmpz_mod, ifmpz_mod]): - - @classmethod - def get(cls, - names: _str | Iterable[_str | tuple[_str, int]] | tuple[_str, int], - ordering: Ordering | _str = Ordering.lex, - *, - modulus: int, - ) -> fmpz_mod_mpoly_ctx: - ... - - def modulus(self) -> fmpz: ... - - def nvars(self) -> int: ... - def ordering(self) -> Ordering: ... - - def gen(self, i: int) -> fmpz_mod_mpoly: ... - def from_dict(self, d: Mapping[tuple[int, ...], ifmpz_mod]) -> fmpz_mod_mpoly: ... - def constant(self, z: ifmpz_mod) -> fmpz_mod_mpoly: ... - - def name(self, i: int, /) -> str: ... - def names(self) -> tuple[str, ...]: ... - def gens(self) -> tuple[fmpz_mod_mpoly, ...]: ... - def variable_to_index(self, var: str, /) -> int: ... - def term( - self, coeff: ifmpz_mod | None = None, exp_vec: Iterable[int] | None = None - ) -> fmpz_mod_mpoly: ... - def drop_gens(self, gens: Iterable[str | int], /) -> fmpz_mod_mpoly_ctx: ... - def append_gens(self, gens: Iterable[str | int], /) -> fmpz_mod_mpoly_ctx: ... - def infer_generator_mapping( - self, ctx: flint_mpoly_context, / - ) -> dict[int, int]: ... - @classmethod - def from_context( - cls, - ctx: flint_mpoly_context[Any, Any, Any], - names: str | Iterable[str | tuple[str, int]] | tuple[str, int] | None = None, - ordering: Ordering | str = Ordering.lex, - ) -> fmpz_mod_mpoly_ctx: ... - - -class fmpz_mod_mpoly(flint_mpoly[fmpz_mod_mpoly_ctx, fmpz_mod, ifmpz_mod]): - def __init__(self, - val: fmpz_mod_mpoly | fmpz_mpoly | ifmpz_mod | Mapping[tuple[int, ...], ifmpz_mod] | _str = 0, - ctx: fmpz_mod_mpoly_ctx | None = None - ) -> None: ... - - def str(self) -> _str: ... - def repr(self) -> _str: ... - - def context(self) -> fmpz_mod_mpoly_ctx: ... - - def degrees(self) -> tuple[int, ...]: ... - def total_degree(self) -> int: ... - - def is_one(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_constant(self) -> bool: ... - - def __len__(self) -> int: ... - def coefficient(self, i: int) -> fmpz_mod: ... - def monomial(self, i: int) -> tuple[int, ...]: ... - - def monoms(self) -> list[tuple[int, ...]]: ... - def coeffs(self) -> list[fmpz_mod]: ... - def __getitem__(self, index: tuple[int, ...]) -> fmpz_mod: ... - def __setitem__(self, index: tuple[int, ...], coeff: ifmpz_mod) -> None: ... - - def subs(self, mapping: Mapping[_str | int, ifmpz_mod]) -> fmpz_mod_mpoly: ... - def compose(self, *args: fmpz_mod_mpoly, ctx: fmpz_mod_mpoly_ctx | None = None) -> fmpz_mod_mpoly: ... - - def __call__(self, *args: ifmpz_mod) -> fmpz_mod: ... - - def __pos__(self) -> fmpz_mod_mpoly: ... - def __neg__(self) -> fmpz_mod_mpoly: ... - def __add__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> fmpz_mod_mpoly: ... - def __radd__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __sub__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> fmpz_mod_mpoly: ... - def __rsub__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __mul__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> fmpz_mod_mpoly: ... - def __rmul__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __truediv__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> fmpz_mod_mpoly: ... - def __rtruediv__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __floordiv__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> fmpz_mod_mpoly: ... - def __rfloordiv__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __mod__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> fmpz_mod_mpoly: ... - def __rmod__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __divmod__(self, other: fmpz_mod_mpoly | ifmpz_mod) -> tuple[fmpz_mod_mpoly, fmpz_mod_mpoly]: ... - def __rdivmod__(self, other: ifmpz_mod) -> tuple[fmpz_mod_mpoly, fmpz_mod_mpoly]: ... - def __pow__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - def __rpow__(self, other: ifmpz_mod) -> fmpz_mod_mpoly: ... - - def iadd(self, other: fmpz_mod_mpoly | ifmpz_mod) -> None: ... - def isub(self, other: fmpz_mod_mpoly | ifmpz_mod) -> None: ... - def imul(self, other: fmpz_mod_mpoly | ifmpz_mod) -> None: ... - - def gcd(self, other: fmpz_mod_mpoly) -> fmpz_mod_mpoly: ... - def xgcd(self, other: fmpz_mod_mpoly, /) -> fmpz_mod: ... - def term_content(self) -> fmpz_mod_mpoly: ... - def primitive(self) -> tuple[fmpz_mod, fmpz_mod_mpoly]: ... - - def factor(self) -> tuple[fmpz_mod, list[tuple[fmpz_mod_mpoly, int]]]: ... - def factor_squarefree(self) -> tuple[fmpz_mod, list[tuple[fmpz_mod_mpoly, int]]]: ... - - def sqrt(self, assume_perfect_square: bool = False) -> fmpz_mod_mpoly: ... - - def resultant(self, other: fmpz_mod_mpoly, var: _str | int) -> fmpz_mod_mpoly: ... - def discriminant(self, var: _str | int) -> fmpz_mod_mpoly: ... - - def deflation(self) -> tuple[fmpz_mod_mpoly, list[int]]: ... - def inflate(self, N: list[int]) -> fmpz_mod_mpoly: ... - def deflate(self, N: list[int]) -> fmpz_mod_mpoly: ... - def deflation_monom(self) -> tuple[fmpz_mod_mpoly, list[int], fmpz_mod_mpoly]: ... - def deflation_index(self) -> tuple[list[int], list[int]]: ... - - def derivative(self, var: _str | int) -> fmpz_mod_mpoly: ... - - -class fmpz_mod_mpoly_vec: - ... - diff --git a/src/flint/types/fmpz_mod_mpoly.pyx b/src/flint/types/fmpz_mod_mpoly.pyx deleted file mode 100644 index 913028ce..00000000 --- a/src/flint/types/fmpz_mod_mpoly.pyx +++ /dev/null @@ -1,1250 +0,0 @@ -cimport cython - -from flint.flintlib.types.flint cimport ulong - -from flint.flint_base.flint_base cimport ( - flint_mpoly, - flint_mod_mpoly_context, - ordering_py_to_c, - ordering_c_to_py, -) - -from flint.flint_base.flint_base import FLINT_RELEASE - -from flint.utils.typecheck cimport typecheck -from flint.utils.flint_exceptions import DomainError, IncompatibleContextError - -from flint.types.fmpz cimport any_as_fmpz, fmpz -from flint.types.fmpz_vec cimport fmpz_vec -from flint.types.fmpz_mod cimport fmpz_mod -from flint.types.nmod cimport nmod - -from flint.flintlib.functions.fmpz cimport fmpz_set -from flint.flintlib.functions.fmpz_mod_mpoly cimport ( - fmpz_mod_mpoly_add, - fmpz_mod_mpoly_add_fmpz, - fmpz_mod_mpoly_clear, - fmpz_mod_mpoly_compose_fmpz_mod_mpoly, - fmpz_mod_mpoly_ctx_get_modulus, - fmpz_mod_mpoly_ctx_init, - fmpz_mod_mpoly_deflate, - fmpz_mod_mpoly_deflation, - fmpz_mod_mpoly_degrees_fmpz, - fmpz_mod_mpoly_derivative, - fmpz_mod_mpoly_discriminant, - fmpz_mod_mpoly_div, - fmpz_mod_mpoly_divides, - fmpz_mod_mpoly_divrem, - fmpz_mod_mpoly_equal, - fmpz_mod_mpoly_equal_fmpz, - fmpz_mod_mpoly_evaluate_all_fmpz, - fmpz_mod_mpoly_evaluate_one_fmpz, - fmpz_mod_mpoly_gcd, - fmpz_mod_mpoly_gen, - fmpz_mod_mpoly_get_coeff_fmpz_fmpz, - fmpz_mod_mpoly_get_str_pretty, - fmpz_mod_mpoly_get_term_coeff_fmpz, - fmpz_mod_mpoly_get_term_exp_fmpz, - fmpz_mod_mpoly_inflate, - fmpz_mod_mpoly_is_one, - fmpz_mod_mpoly_is_zero, - fmpz_mod_mpoly_length, - fmpz_mod_mpoly_mul, - fmpz_mod_mpoly_neg, - fmpz_mod_mpoly_pow_fmpz, - fmpz_mod_mpoly_push_term_fmpz_ffmpz, - fmpz_mod_mpoly_push_term_ui_ffmpz, - fmpz_mod_mpoly_resultant, - fmpz_mod_mpoly_scalar_mul_fmpz, - fmpz_mod_mpoly_set, - fmpz_mod_mpoly_set_coeff_fmpz_fmpz, - fmpz_mod_mpoly_set_fmpz, - fmpz_mod_mpoly_set_str_pretty, - fmpz_mod_mpoly_sort_terms, - fmpz_mod_mpoly_sqrt, - fmpz_mod_mpoly_sub, - fmpz_mod_mpoly_sub_fmpz, - fmpz_mod_mpoly_term_content, - fmpz_mod_mpoly_total_degree_fmpz, -) -from flint.flintlib.functions.fmpz_mod_mpoly_factor cimport ( - fmpz_mod_mpoly_factor, - fmpz_mod_mpoly_factor_clear, - fmpz_mod_mpoly_factor_init, - fmpz_mod_mpoly_factor_squarefree, - fmpz_mod_mpoly_factor_t, -) -from flint.flintlib.functions.compat cimport compat_fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen - -from flint.types.fmpz_mpoly cimport fmpz_mpoly_ctx, fmpz_mpoly - - -from cpython.object cimport Py_EQ, Py_NE -cimport libc.stdlib - -cdef dict _fmpz_mod_mpoly_ctx_cache = {} - - -cdef class fmpz_mod_mpoly_ctx(flint_mod_mpoly_context): - """ - A class for storing the polynomial context - - :param names: A tuple containing the names of the variables of the ring. - :param ordering: The term order for the ring. - :param modulus: The modulus for the ring. - - Do not construct one of these directly, use ``fmpz_mod_mpoly_ctx.get``. - """ - - _ctx_cache = _fmpz_mod_mpoly_ctx_cache - - @classmethod - def _new_(cls, names, ordering, modulus): - cdef fmpz_mod_mpoly_ctx self = cls.__new__(cls) - cdef fmpz m - if not typecheck(modulus, fmpz): - m = any_as_fmpz(modulus) - if m is NotImplemented: - raise TypeError(f"modulus ({modulus}) is not coercible to fmpz") - else: - m = modulus - - super()._new_(self, names, m.is_prime()) - fmpz_mod_mpoly_ctx_init(self.val, len(names), ordering_py_to_c(ordering), m.val) - return self - - def _any_as_scalar(self, other): - if isinstance(other, int): - return any_as_fmpz(other) - elif typecheck(other, nmod): - return any_as_fmpz((other).val) - elif typecheck(other, fmpz): - res = fmpz.__new__(fmpz) - fmpz_set((res).val, (other).val) - return res - elif typecheck(other, fmpz_mod): - res = fmpz.__new__(fmpz) - fmpz_set((res).val, (other).val) - return res - else: - return NotImplemented - - def _scalar_as_mpoly(self, other: fmpz): - # non-fmpz scalars should first be converted via self._any_as_scalar - return self.constant(other) - - def nvars(self): - """ - Return the number of variables in the context - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 4), 11, 'lex') - >>> ctx.nvars() - 4 - """ - return self.val.minfo.nvars - - def ordering(self): - """ - Return the term order of the context object. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('w', 4), 11, 'deglex') - >>> ctx.ordering() - - """ - return ordering_c_to_py(self.val.minfo.ord) - - def modulus(self): - """ - Return the modulus of the context object. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('w', 4), 2, 'deglex') - >>> ctx.modulus() - 2 - - """ - cdef fmpz m = fmpz.__new__(fmpz) - fmpz_mod_mpoly_ctx_get_modulus(m.val, self.val) - return m - - def gen(self, slong i): - """ - Return the ``i`` th generator of the polynomial ring - - >>> ctx = fmpz_mod_mpoly_ctx.get(('z', 3), 11, 'degrevlex') - >>> ctx.gen(1) - z1 - """ - cdef fmpz_mod_mpoly res - if not 0 <= i < self.val.minfo.nvars: - raise IndexError("generator index out of range") - res = create_fmpz_mod_mpoly(self) - fmpz_mod_mpoly_gen(res.val, i, res.ctx.val) - return res - - def constant(self, z): - """ - Create a constant polynomial in this context - """ - cdef fmpz_mod_mpoly res - z = any_as_fmpz(z) - if z is NotImplemented: - raise TypeError("cannot coerce argument to fmpz") - res = create_fmpz_mod_mpoly(self) - fmpz_mod_mpoly_set_fmpz(res.val, (z).val, res.ctx.val) - return res - - def from_dict(self, d): - """ - Create a fmpz_mod_mpoly from a dictionary in this context. - - The dictionary's keys are tuples of ints (or anything that implicitly converts - to fmpz) representing exponents, and corresponding values of fmpz. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> ctx.from_dict({(1,0):2, (1,1):3, (0,1):1}) - 3*x*y + 2*x + y - """ - cdef: - fmpz_vec exp_vec - slong i, nvars = self.nvars() - fmpz_mod_mpoly res - - if not isinstance(d, dict): - raise ValueError("expected a dictionary") - - res = create_fmpz_mod_mpoly(self) - - for i, (exps, coeff) in enumerate(d.items()): - if len(exps) != nvars: - raise ValueError(f"expected {nvars} exponents, got {len(exps)}") - elif not coeff: - continue - - exp_vec = fmpz_vec(exps) - coeff_scalar = self._any_as_scalar(coeff) - if coeff_scalar is NotImplemented: - raise TypeError(f"cannot coerce {repr(coeff)} to nmod_mpoly coefficient") - - fmpz_mod_mpoly_push_term_fmpz_ffmpz( - res.val, - (coeff_scalar).val, - exp_vec.val, - self.val - ) - - fmpz_mod_mpoly_sort_terms(res.val, self.val) - return res - - -cdef class fmpz_mod_mpoly(flint_mpoly): - """ - The *fmpz_mod_mpoly* type represents sparse multivariate polynomials over - the integers modulo ``n``, for large ``n``. - """ - - def __cinit__(self): - self._init = False - - def __dealloc__(self): - if self._init: - fmpz_mod_mpoly_clear(self.val, self.ctx.val) - self._init = False - - def __init__(self, val=0, ctx=None): - if typecheck(val, fmpz_mod_mpoly): - if ctx is None or ctx == (val).ctx: - init_fmpz_mod_mpoly(self, (val).ctx) - fmpz_mod_mpoly_set(self.val, (val).val, self.ctx.val) - else: - raise IncompatibleContextError(f"{ctx} is not {(val).ctx}") - elif isinstance(val, dict): - if ctx is None: - raise ValueError("a context is required to create a fmpz_mod_mpoly from a dict") - x = ctx.from_dict(val) - # XXX: this copy is silly, have a ctx function that assigns an fmpz_mod_mpoly_t - init_fmpz_mod_mpoly(self, ctx) - fmpz_mod_mpoly_set(self.val, (x).val, self.ctx.val) - elif isinstance(val, str): - if ctx is None: - raise ValueError("cannot parse a polynomial without context") - val = bytes(val, 'utf-8') - init_fmpz_mod_mpoly(self, ctx) - if fmpz_mod_mpoly_set_str_pretty(self.val, val, self.ctx.c_names, self.ctx.val) == -1: - raise ValueError("unable to parse fmpz_mod_mpoly from string") - fmpz_mod_mpoly_sort_terms(self.val, self.ctx.val) - elif typecheck(val, fmpz_mod): - if ctx is None: - raise ValueError("need context to convert fmpz_mod to fmpz_mod_mpoly") - init_fmpz_mod_mpoly(self, ctx) - fmpz_mod_mpoly_set_fmpz(self.val, (val).val, self.ctx.val) - else: - v = any_as_fmpz(val) - if v is NotImplemented: - raise TypeError("cannot create fmpz_mod_mpoly from type %s" % type(val)) - elif ctx is None: - raise ValueError("need context to convert fmpz to fmpz_mod_mpoly") - init_fmpz_mod_mpoly(self, ctx) - fmpz_mod_mpoly_set_fmpz(self.val, (v).val, self.ctx.val) - - def _division_check(self, other): - super()._division_check(other) - if not self.ctx.is_prime(): - raise DomainError("division with non-prime modulus is not supported") - - def __bool__(self): - return not fmpz_mod_mpoly_is_zero(self.val, self.ctx.val) - - def is_zero(self): - return fmpz_mod_mpoly_is_zero(self.val, self.ctx.val) - - def is_one(self): - return fmpz_mod_mpoly_is_one(self.val, self.ctx.val) - - def is_constant(self): - """ - Returns True if this is a constant polynomial. - - >>> R = fmpz_mod_mpoly_ctx.get(['x', 'y'], modulus=11) - >>> x, y = R.gens() - >>> x.is_constant() - False - >>> (0*x + 1).is_constant() - True - """ - return self.total_degree() <= 0 - - def __richcmp__(self, other, int op): - if not (op == Py_EQ or op == Py_NE): - return NotImplemented - elif other is None: - return op == Py_NE - elif typecheck(self, fmpz_mod_mpoly) and typecheck(other, fmpz_mod_mpoly): - if (self).ctx is (other).ctx: - return (op == Py_NE) ^ bool( - fmpz_mod_mpoly_equal((self).val, (other).val, (self).ctx.val) - ) - else: - return op == Py_NE - elif typecheck(other, fmpz): - return (op == Py_NE) ^ fmpz_mod_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - elif typecheck(other, fmpz_mod): - return (op == Py_NE) ^ fmpz_mod_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - elif isinstance(other, int): - other = any_as_fmpz(other) - if other is NotImplemented: - return NotImplemented - return (op == Py_NE) ^ fmpz_mod_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - else: - return NotImplemented - - def __len__(self): - return fmpz_mod_mpoly_length(self.val, self.ctx.val) - - def __getitem__(self, x): - """ - Return the coefficient of the term with the exponent vector ``x``. - Always returns a value, missing keys will return ``0``. - Negative exponents are made positive. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] - 3 - - """ - cdef: - slong nvars = self.ctx.nvars() - - if not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - res = fmpz() - exp_vec = fmpz_vec(x, double_indirect=True) - fmpz_mod_mpoly_get_coeff_fmpz_fmpz((res).val, self.val, exp_vec.double_indirect, self.ctx.val) - return res - - def __setitem__(self, x, y): - """ - Set the coefficient of the term with the exponent vector ``x`` to ``y``. - Will always set a value, missing keys will create a new term. - Negative exponents are made positive. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] = 20 - >>> p - 9*x0*x1 + 2*x1 - - """ - cdef: - slong nvars = self.ctx.nvars() - - if not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - exp_vec = fmpz_vec(x, double_indirect=True) - - coeff = self.ctx._any_as_scalar(y) - if coeff is NotImplemented: - raise TypeError("provided coefficient not coercible to fmpz") - fmpz_mod_mpoly_set_coeff_fmpz_fmpz(self.val, (coeff).val, exp_vec.double_indirect, self.ctx.val) - - def __neg__(self): - cdef fmpz_mod_mpoly res - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_neg(res.val, (self).val, res.ctx.val) - return res - - cdef _add_scalar_(self, arg): - cdef fmpz_mod_mpoly res - cdef fmpz other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_add_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _sub_scalar_(self, arg): - cdef fmpz_mod_mpoly res - cdef fmpz other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_sub_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _mul_scalar_(self, arg): - cdef fmpz_mod_mpoly res - cdef fmpz other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_scalar_mul_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _pow_(self, arg): - cdef fmpz_mod_mpoly res - cdef fmpz other = arg - res = create_fmpz_mod_mpoly(self.ctx) - if fmpz_mod_mpoly_pow_fmpz(res.val, self.val, other.val, res.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - cdef _add_mpoly_(self, arg): - cdef fmpz_mod_mpoly res, other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_add(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _sub_mpoly_(self, arg): - cdef fmpz_mod_mpoly res, other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_sub(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _mul_mpoly_(self, arg): - cdef fmpz_mod_mpoly res, other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_mul(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _divmod_mpoly_(self, arg): - cdef fmpz_mod_mpoly quotient, remainder, other = arg - quotient = create_fmpz_mod_mpoly(self.ctx) - remainder = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return (quotient, remainder) - - cdef _floordiv_mpoly_(self, arg): - cdef fmpz_mod_mpoly quotient, other = arg - quotient = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_div(quotient.val, self.val, other.val, self.ctx.val) - return quotient - - cdef _truediv_mpoly_(self, arg): - cdef fmpz_mod_mpoly quotient, other = arg - quotient = create_fmpz_mod_mpoly(self.ctx) - if fmpz_mod_mpoly_divides(quotient.val, self.val, other.val, self.ctx.val): - return quotient - else: - raise DomainError("fmpz_mod_mpoly division is not exact") - - cdef _mod_mpoly_(self, arg): - cdef fmpz_mod_mpoly quotient, remainder, other = arg - quotient = create_fmpz_mod_mpoly(self.ctx) - remainder = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return remainder - - cdef _rsub_scalar_(self, arg): - cdef fmpz_mod_mpoly res - cdef fmpz other = arg - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_sub_fmpz(res.val, self.val, other.val, self.ctx.val) - fmpz_mod_mpoly_neg(res.val, res.val, res.ctx.val) - return res - - cdef _rsub_mpoly_(self, arg): - return (arg)._sub_mpoly_(self) - - cdef _rdivmod_mpoly_(self, arg): - return (arg)._divmod_mpoly_(self) - - cdef _rfloordiv_mpoly_(self, arg): - return (arg)._floordiv_mpoly_(self) - - cdef _rtruediv_mpoly_(self, arg): - return (arg)._truediv_mpoly_(self) - - cdef _rmod_mpoly_(self, arg): - return (arg)._mod_mpoly_(self) - - cdef _iadd_scalar_(self, arg): - cdef fmpz other = arg - fmpz_mod_mpoly_add_fmpz(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_scalar_(self, arg): - cdef fmpz other = arg - fmpz_mod_mpoly_sub_fmpz(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_scalar_(self, arg): - cdef fmpz other = arg - fmpz_mod_mpoly_scalar_mul_fmpz(self.val, self.val, other.val, self.ctx.val) - - cdef _iadd_mpoly_(self, arg): - cdef fmpz_mod_mpoly other = arg - fmpz_mod_mpoly_add(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_mpoly_(self, arg): - cdef fmpz_mod_mpoly other = arg - fmpz_mod_mpoly_sub(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_mpoly_(self, arg): - cdef fmpz_mod_mpoly other = arg - fmpz_mod_mpoly_mul(self.val, self.val, other.val, self.ctx.val) - - def __call__(self, *args) -> fmpz: - cdef: - fmpz_vec V - fmpz vres - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs != nvars: - raise ValueError("number of generators does not match number of arguments") - args = [self.ctx._any_as_scalar(x) for x in args] - V = fmpz_vec(args, double_indirect=True) - vres = fmpz.__new__(fmpz) - fmpz_mod_mpoly_evaluate_all_fmpz(vres.val, self.val, V.double_indirect, self.ctx.val) - return vres - - def monoms(self): - """ - Return the exponent vectors of each term as a tuple of fmpz. - - >>> ctx = fmpz_mod_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)] - - """ - cdef: - slong i, nvars = self.ctx.nvars() - fmpz_vec vec = fmpz_vec(nvars, double_indirect=True) - - res = [] - for i in range(len(self)): - fmpz_mod_mpoly_get_term_exp_fmpz(vec.double_indirect, self.val, i, self.ctx.val) - res.append(tuple(vec)) - - return res - - def coeffs(self): - """ - Return the coefficients of each term as a fmpz - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> f = ctx.from_dict({(0, 0): 1, (1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> f.coeffs() - [4, 2, 3, 1] - - """ - cdef: - fmpz coeff - slong i - - res = [] - for i in range(len(self)): - coeff = fmpz.__new__(fmpz) - fmpz_mod_mpoly_get_term_coeff_fmpz(coeff.val, self.val, i, self.ctx.val) - res.append(coeff) - - return res - - def subs(self, dict_args) -> fmpz_mod_mpoly: - """ - Partial evaluate this polynomial with select constants. Keys must be generator names or generator indices, - all values must be fmpz. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> f = ctx.from_dict({(0, 0): 1, (1, 0): 2, (0, 1): 3, (1, 1): 4}) - >>> f.subs({"x1": 0}) - 2*x0 + 1 - - """ - cdef: - fmpz_mod_mpoly res - slong i - - args = tuple((self.ctx.variable_to_index(k), self.ctx._any_as_scalar(v)) for k, v in dict_args.items()) - for (_, v), old in zip(args, dict_args.values()): - if v is NotImplemented: - raise TypeError(f"cannot coerce {type(old)} to fmpz") - - # Partial application with args in Z. We evaluate the polynomial one variable at a time - res = create_fmpz_mod_mpoly(self.ctx) - - fmpz_mod_mpoly_set(res.val, self.val, self.ctx.val) - for i, arg in args: - fmpz_mod_mpoly_evaluate_one_fmpz(res.val, res.val, i, (arg).val, self.ctx.val) - return res - - def compose(self, *args, ctx=None) -> fmpz_mod_mpoly: - """ - Compose this polynomial with other fmpz_mod_mpolys. All arguments must share the same context, it may different - from this polynomials context. - - >>> 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 - - """ - cdef: - fmpz_mod_mpoly res - fmpz_mod_mpoly_ctx res_ctx - fmpz_mod_mpoly_vec C - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs != nvars: - raise ValueError("number of generators does not match number of arguments") - elif self.ctx.nvars() == 0 and ctx is None: - raise ValueError("a context must be provided when composing a polynomial with no generators") - elif not all(typecheck(arg, fmpz_mod_mpoly) for arg in args): - raise TypeError("all arguments must be fmpz_mod_mpolys") - - if ctx is None: - res_ctx = ( args[0]).ctx - elif typecheck(ctx, fmpz_mod_mpoly_ctx): - res_ctx = ctx - else: - raise TypeError(f"provided context ({ctx}) is not a fmpz_mod_mpoly_ctx") - - if not all(( arg).ctx is res_ctx for arg in args): - raise IncompatibleContextError( - "all arguments must share the " + ("same" if ctx is not None else "provided") + " context" - ) - - C = fmpz_mod_mpoly_vec(args, res_ctx, double_indirect=True) - res = create_fmpz_mod_mpoly(res_ctx) - if fmpz_mod_mpoly_compose_fmpz_mod_mpoly(res.val, self.val, C.double_indirect, self.ctx.val, res_ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - def context(self): - """ - Return the context object for this polynomials. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2}) - >>> ctx is p.context() - True - """ - return self.ctx - - def coefficient(self, slong i): - """ - Return the coefficient at index ``i``. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.coefficient(1) - 2 - """ - cdef fmpz v - if not 0 <= i < fmpz_mod_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - else: - v = fmpz.__new__(fmpz) - fmpz_mod_mpoly_get_term_coeff_fmpz(v.val, self.val, i, self.ctx.val) - return v - - def monomial(self, slong i): - """ - Return the exponent vector at index ``i`` as a tuple. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.monomial(1) - (0, 1) - """ - cdef: - slong nvars = self.ctx.nvars() - - if not 0 <= i < fmpz_mod_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - res = fmpz_vec(nvars, double_indirect=True) - fmpz_mod_mpoly_get_term_exp_fmpz(res.double_indirect, self.val, i, self.ctx.val) - return tuple(res) - - def degrees(self): - """ - Return a dictionary of variable name to degree. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 4), 11, 'lex') - >>> p = sum(x**i for i, x in enumerate(ctx.gens())) - >>> p - x1 + x2^2 + x3^3 + 1 - >>> p.degrees() - (0, 1, 2, 3) - """ - cdef: - slong nvars = self.ctx.nvars() - - res = fmpz_vec(nvars, double_indirect=True) - fmpz_mod_mpoly_degrees_fmpz(res.double_indirect, self.val, self.ctx.val) - return tuple(res) - - def total_degree(self): - """ - Return the total degree. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 4), 11, 'lex') - >>> p = ctx.from_dict({(1, 0, 0, 0): 1, (0, 2, 0, 0): 2, (0, 0, 3, 0): 3}) - >>> p.total_degree() - 3 - """ - cdef fmpz res = fmpz() - fmpz_mod_mpoly_total_degree_fmpz(( res).val, self.val, self.ctx.val) - return res - - def leading_coefficient(self): - """ - Leading coefficient in the monomial ordering. - - >>> ctx = fmpz_mod_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 - - """ - if fmpz_mod_mpoly_is_zero(self.val, self.ctx.val): - return fmpz(0) - else: - return self.coefficient(0) - - def repr(self): - return f"{self.ctx}.from_dict({self.to_dict()})" - - def str(self): - cdef bytes s = fmpz_mod_mpoly_get_str_pretty(self.val, self.ctx.c_names, self.ctx.val) - res = s.decode().replace("+", " + ").replace("-", " - ") - if res.startswith(" - "): - res = "-" + res[3:] - return res - - def gcd(self, other): - """ - Return the gcd of self and other. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> g = ctx.from_dict({(0, 1): 2, (1, 0): 2}) - >>> (f * g).gcd(f) - x0*x1 + 3 - """ - cdef fmpz_mod_mpoly res - if not typecheck(other, fmpz_mod_mpoly): - raise TypeError("argument must be a fmpz_mod_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - elif not self.ctx.is_prime(): - raise DomainError("gcd with non-prime modulus is not supported") - res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_gcd(res.val, (self).val, (other).val, res.ctx.val) - return res - - def term_content(self): - """ - Return the GCD of the terms of ``self``. If ``self`` is zero, then the result will - be zero, otherwise it will be a monomial with positive coefficient. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> x0, x1 = ctx.gens() - >>> f = 3 * x0**2 * x1 + 6 * x0 * x1 - >>> f.term_content() - x0*x1 - """ - - cdef fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_term_content(res.val, self.val, self.ctx.val) - return res - - def resultant(self, other, var): - """ - Return the resultant of ``self`` and ``other`` with respect to variable ``var``. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> x0, x1 = ctx.gens() - >>> f = x0**2 * x1 + x0 * x1 - >>> g = x0 + x1 - >>> f.resultant(g, 'x1') - x0^3 + x0^2 - """ - cdef: - fmpz_mod_mpoly res - slong i - - if not typecheck(other, fmpz_mod_mpoly): - raise TypeError("argument must be a fmpz_mod_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - - i = self.ctx.variable_to_index(var) - res = create_fmpz_mod_mpoly(self.ctx) - if not fmpz_mod_mpoly_resultant(res.val, self.val, (other).val, i, self.ctx.val): - raise RuntimeError(f"failed to compute resultant with respect to {var}") - return res - - def discriminant(self, var): - """ - Return the discriminant of ``self`` with respect to variable ``var``. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> x0, x1 = ctx.gens() - >>> f = (x0 + x1)**2 + 1 - >>> f.discriminant('x1') - 7 - - """ - cdef: - fmpz_mod_mpoly res - slong i - - i = self.ctx.variable_to_index(var) - res = create_fmpz_mod_mpoly(self.ctx) - if not fmpz_mod_mpoly_discriminant(res.val, self.val, i, self.ctx.val): - raise RuntimeError(f"failed to compute discriminant with respect to {var}") - return res - - def sqrt(self): - """ - Return the square root of self. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> (f * f).sqrt() - 4*x0*x1 + 1 - """ - cdef fmpz_mod_mpoly res - if not self.ctx.is_prime(): - raise DomainError("square root with non-prime modulus is not supported") - - res = create_fmpz_mod_mpoly(self.ctx) - - if fmpz_mod_mpoly_sqrt(res.val, self.val, self.ctx.val): - return res - else: - raise DomainError("polynomial is not a perfect square") - - def factor(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = fmpz_mod_mpoly - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y', 'z'), 11, 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*z + 3*x + 3*z + 3", ctx) - >>> (p1 * p2).factor() - (6, [(z + 1, 1), (x + 1, 1), (x + 2, 1)]) - >>> (p2 * p1 * p2).factor() - (7, [(x + 2, 1), (z + 1, 2), (x + 1, 2)]) - """ - cdef: - fmpz_mod_mpoly_factor_t fac - fmpz c - fmpz_mod_mpoly u - - if not self.ctx.is_prime(): - raise DomainError("factorisation with non-prime modulus is not supported") - - fmpz_mod_mpoly_factor_init(fac, self.ctx.val) - if not fmpz_mod_mpoly_factor(fac, self.val, self.ctx.val): - raise RuntimeError("factorisation failed") - res = [0] * fac.num - - for i in range(fac.num): - u = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, fac.constant) - fmpz_mod_mpoly_factor_clear(fac, self.ctx.val) - - res.sort(key=_fmpz_mod_mpoly_sort_key) - - return c, res - - def factor_squarefree(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = fmpz_mod_mpoly - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y', 'z'), 11, 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*y + 3*x + 3*y + 3", ctx) - >>> (p1 * p2).factor_squarefree() - (6, [(y + 1, 1), (x^2 + 3*x + 2, 1)]) - >>> (p1 * p2 * p1).factor_squarefree() - (1, [(y + 1, 1), (x + 1, 1), (x + 2, 2)]) - """ - cdef: - fmpz_mod_mpoly_factor_t fac - fmpz c - fmpz_mod_mpoly u - - if not self.ctx.is_prime(): - raise DomainError("factorisation with non-prime modulus is not supported") - - fmpz_mod_mpoly_factor_init(fac, self.ctx.val) - if not fmpz_mod_mpoly_factor_squarefree(fac, self.val, self.ctx.val): - raise RuntimeError("factorisation failed") - res = [0] * fac.num - - for i in range(fac.num): - u = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_init(u.val, u.ctx.val) - fmpz_mod_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, fac.constant) - fmpz_mod_mpoly_factor_clear(fac, self.ctx.val) - return c, res - - def derivative(self, var): - """ - Return the derivative of this polynomial with respect to the provided variable. - The argument can either be the variable as a string, or the index of the - variable in the context. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 3): 2, (2, 1): 3}) - >>> p - 3*x0^2*x1 + 2*x1^3 - >>> p.derivative("x0") - 6*x0*x1 - >>> p.derivative(1) - 3*x0^2 + 6*x1^2 - - """ - cdef: - fmpz_mod_mpoly res - slong i = self.ctx.variable_to_index(var) - - res = create_fmpz_mod_mpoly(self.ctx) - - fmpz_mod_mpoly_derivative(res.val, self.val, i, self.ctx.val) - return res - - def inflate(self, N: list[int]) -> fmpz_mod_mpoly: - """ - Compute the inflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^N)``. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x + y + 1 - >>> f.inflate([2, 3]) - x^2 + y^3 + 1 - """ - - cdef nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - elif any(n < 0 for n in N): - raise ValueError("all inflate strides must be non-negative") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx) - - fmpz_mod_mpoly_inflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - return res - - def deflate(self, N: list[int]) -> fmpz_mod_mpoly: - """ - Compute the deflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^(1/N))``. - - >>> 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 - """ - cdef slong nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx) - - fmpz_mod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - return res - - def deflation(self) -> tuple[fmpz_mod_mpoly, list[int]]: - """ - Compute the deflation of ``self``, that is ``p(X^(1/N))`` for maximal - N. Returns ``q, N`` such that ``self == q.inflate(N)``. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x**2 * y**2 + x * y**2 - >>> q, N = f.deflation() - >>> q, N - (x^2*y + x*y, [1, 2]) - >>> q.inflate(N) == f - True - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx) - - fmpz_mod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - - for i in range(nvars): - stride[i] = shift[i].gcd(stride[i]) - shift[i] = 0 - - fmpz_mod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - - return res, list(stride) - - def deflation_monom(self) -> tuple[fmpz_mod_mpoly, list[int], fmpz_mod_mpoly]: - """ - Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N)) - = m * q(X^N)`` for maximal N. The returned monomial allows the undo-ing of the - deflation. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> fd, N, m = f.deflation_monom() - >>> fd, N, m - (x + y + 1, [2, 3], x*y) - >>> m * fd.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_mod_mpoly res = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly monom = create_fmpz_mod_mpoly(self.ctx) - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - fmpz_mod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - fmpz_mod_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val) - fmpz_mod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - - return res, list(stride), monom - - def deflation_index(self) -> tuple[list[int], list[int]]: - """ - Compute the exponent vectors ``N`` and ``I`` such that ``p(X^(1/N)) = X^I * - q(X^N)`` for maximal N. Importantly the deflation itself is not computed - here. The returned exponent vector ``I`` is the shift that was applied to the - exponents. It is the exponent vector of the monomial returned by - ``deflation_monom``. - - >>> ctx = fmpz_mod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> N, I = f.deflation_index() - >>> N, I - ([2, 3], [1, 1]) - >>> f_deflated = f.deflate(N) - >>> f_deflated - x + y + 1 - >>> m = ctx.term(exp_vec=I) - >>> m - x*y - >>> m * f_deflated.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - fmpz_mod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - return list(stride), list(shift) - - cdef _compose_gens_(self, ctx, slong *mapping): - # FIXME: Remove this when FLINT < 3.2 is dropped - cdef fmpz_mod_mpoly res - if FLINT_RELEASE >= 30200: - res = create_fmpz_mod_mpoly(ctx) - compat_fmpz_mod_mpoly_compose_fmpz_mod_mpoly_gen( - res.val, - self.val, - mapping, - self.ctx.val, - (ctx).val - ) - return res - - cdef: - fmpz_mpoly_ctx mpoly_ctx = fmpz_mpoly_ctx.from_context(self.context()) - fmpz_mpoly_ctx res_ctx = fmpz_mpoly_ctx.from_context(ctx) - - fmpz_mpoly poly = mpoly_ctx.from_dict(self.to_dict()) - fmpz_mpoly res1 = poly._compose_gens_(res_ctx, mapping) - - return ctx.from_dict(res1.to_dict()) - - -@cython.final -@cython.no_gc -cdef class _fmpz_mod_mpoly_sort_key: - cdef fmpz_mod_mpoly p - cdef ulong mult - - def __init__(self, tuple fac_m): - self.p = fac_m[0] - self.mult = fac_m[1] - - def __lt__(k1, _fmpz_mod_mpoly_sort_key k2): - cdef slong nterms - cdef tuple monom1, monom2 - cdef int coeff1, coeff2 - if k1.mult != k2.mult: - return k1.mult < k2.mult - nterms = min(k1.p.val.length, k2.p.val.length) - for i in range(nterms): - monom1 = k1.p.monomial(i) - monom2 = k2.p.monomial(i) - if monom1 != monom2: - return monom1 < monom2 - coeff1 = int(k1.p.coefficient(i)) - coeff2 = int(k2.p.coefficient(i)) - if coeff1 != coeff2: - return coeff1 < coeff2 - return k1.p.val.length < k2.p.val.length - - -cdef class fmpz_mod_mpoly_vec: - """ - A class representing a vector of fmpz_mod_mpolys. - """ - - def __cinit__(self, iterable_or_len, fmpz_mod_mpoly_ctx ctx, bint double_indirect = False): - if isinstance(iterable_or_len, int): - self.length = iterable_or_len - else: - self.length = len(iterable_or_len) - - self.ctx = ctx - - self.val = libc.stdlib.malloc(self.length * sizeof(fmpz_mod_mpoly_struct)) - for i in range(self.length): - fmpz_mod_mpoly_init(&self.val[i], self.ctx.val) - - if double_indirect: - self.double_indirect = libc.stdlib.malloc(self.length * sizeof(fmpz_mod_mpoly_struct *)) - if self.double_indirect is NULL: - raise MemoryError("malloc returned a null pointer") # pragma: no cover - - for i in range(self.length): - self.double_indirect[i] = &self.val[i] - else: - self.double_indirect = NULL - - def __init__(self, iterable_or_len, _, double_indirect: bool = False): - if not isinstance(iterable_or_len, int): - for i, x in enumerate(iterable_or_len): - self[i] = x - - def __dealloc__(self): - libc.stdlib.free(self.double_indirect) - for i in range(self.length): - fmpz_mod_mpoly_clear(&self.val[i], self.ctx.val) - libc.stdlib.free(self.val) - - def __getitem__(self, x): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - cdef fmpz_mod_mpoly z = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_set(z.val, &self.val[x], self.ctx.val) - return z - - def __setitem__(self, x, y): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - elif not typecheck(y, fmpz_mod_mpoly): - raise TypeError("argument is not fmpz_mod_mpoly") - elif (y).ctx is not self.ctx: - raise IncompatibleContextError(f"{(y).ctx} is not {self.ctx}") - - fmpz_mod_mpoly_set(&self.val[x], (y).val, self.ctx.val) - - def __len__(self): - return self.val.length - - def __str__(self): - s = [None] * self.length - for i in range(self.length): - x = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_set(x.val, &self.val[x], self.ctx.val) - s[i] = str(x) - return f"[{', '.join(s)}]" - - def __repr__(self): - return f"fmpz_mod_mpoly_vec({self}, ctx={self.ctx})" - - def __iter__(self): - cdef fmpz_mod_mpoly z - for i in range(self.val.length): - z = create_fmpz_mod_mpoly(self.ctx) - fmpz_mod_mpoly_set(z.val, &self.val[i], self.ctx.val) - yield z diff --git a/src/flint/types/fmpz_mod_poly.pxd b/src/flint/types/fmpz_mod_poly.pxd deleted file mode 100644 index f6510979..00000000 --- a/src/flint/types/fmpz_mod_poly.pxd +++ /dev/null @@ -1,18 +0,0 @@ -from flint.flintlib.functions.fmpz_mod_poly cimport * - -from flint.flint_base.flint_base cimport flint_poly -from flint.types.fmpz_mod cimport fmpz_mod_ctx - - -cdef class fmpz_mod_poly_ctx: - cdef fmpz_mod_ctx mod - cdef any_as_fmpz_mod_poly(self, obj) - cdef set_any_as_fmpz_mod_poly(self, fmpz_mod_poly_t poly, obj) - cdef set_list_as_fmpz_mod_poly(self, fmpz_mod_poly_t poly, val) - cdef new_ctype_poly(self) - -cdef class fmpz_mod_poly(flint_poly): - cdef fmpz_mod_poly_t val - cdef fmpz_mod_poly_ctx ctx - cpdef long length(self) - cpdef long degree(self) diff --git a/src/flint/types/fmpz_mod_poly.pyi b/src/flint/types/fmpz_mod_poly.pyi deleted file mode 100644 index bd863ba6..00000000 --- a/src/flint/types/fmpz_mod_poly.pyi +++ /dev/null @@ -1,149 +0,0 @@ -from typing import Literal, Sequence, overload - -from flint.flint_base.flint_base import flint_poly -from flint.types.fmpz import fmpz -from flint.types.fmpz_poly import fmpz_poly -from flint.types.fmpz_mod import fmpz_mod, fmpz_mod_ctx, ifmpz, ifmpz_mod - -ifmpz_mod_poly = ifmpz_mod | fmpz_mod_poly | fmpz_poly - -class fmpz_mod_poly_ctx: - r""" - Context object for creating :class:`~.fmpz_mod_poly` initialised - with a modulus :math:`N`. - - >>> fmpz_mod_poly_ctx(2**127 - 1) - fmpz_mod_poly_ctx(170141183460469231731687303715884105727) - - """ - def __init__(self, mod: fmpz_mod_ctx | ifmpz): ... - def modulus(self) -> fmpz: ... - def is_prime(self) -> bool: ... - def zero(self) -> fmpz_mod_poly: ... - def one(self) -> fmpz_mod_poly: ... - def gen(self) -> fmpz_mod_poly: ... - def random_element( - self, degree: int = 3, monic: bool = False, irreducible: bool = False - ) -> fmpz_mod_poly: ... - def __eq__(self, other: object) -> bool: ... - def __hash__(self) -> int: ... - def __str__(self) -> str: ... - def __repr__(self) -> str: ... - def __call__(self, val: ifmpz_mod_poly | list[ifmpz_mod]) -> fmpz_mod_poly: ... - def minpoly(self, vals: Sequence[ifmpz_mod]) -> fmpz_mod_poly: ... - -class fmpz_mod_poly(flint_poly[fmpz_mod]): - """ - The *fmpz_mod_poly* type represents univariate polynomials - over integer modulo an arbitrary-size modulus. - For wordsize modulus, see :class:`~.nmod_poly`. - - An *fmpz_mod_poly* element is constructed from an :class:`~.fmpz_mod_poly_ctx` - either by passing it as an argument to the type, or - by directly calling the context: - - >>> fmpz_mod_poly([1,-2,3], fmpz_mod_poly_ctx(2**127 - 1)) - 3*x^2 + 170141183460469231731687303715884105725*x + 1 - >>> R = fmpz_mod_poly_ctx(2**127 - 1) - >>> R([4,5,6]) - 6*x^2 + 5*x + 4 - - """ - def __init__(self, val: Sequence[ifmpz_mod] | ifmpz_mod_poly, ctx): ... - def context(self) -> fmpz_mod_poly_ctx: ... - def modulus(self) -> fmpz: ... - def __pos__(self) -> fmpz_mod_poly: ... - def __neg__(self) -> fmpz_mod_poly: ... - def __add__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __radd__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __sub__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __rsub__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __mul__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __rmul__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __truediv__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __rtruediv__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __floordiv__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __rfloordiv__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __mod__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __rmod__(self, other: ifmpz_mod_poly, /) -> fmpz_mod_poly: ... - def __pow__( - self, e: ifmpz, mod: ifmpz_mod_poly | None = None, / - ) -> fmpz_mod_poly: ... - def scalar_mul(self, other: ifmpz_mod) -> fmpz_mod_poly: ... - def exact_division(self, right: ifmpz_mod_poly) -> fmpz_mod_poly: ... - def left_shift(self, n: int, /) -> fmpz_mod_poly: ... - def right_shift(self, n: int, /) -> fmpz_mod_poly: ... - def __getitem__(self, i: int, /) -> fmpz_mod: ... - def __setitem__(self, i: int, x: ifmpz_mod, /) -> None: ... - def __len__(self) -> int: ... - def __hash__(self) -> int: ... - @overload - def __call__(self, input: ifmpz_mod) -> fmpz_mod: ... - @overload - def __call__(self, input: fmpz_mod_poly) -> fmpz_mod_poly: ... - @overload - def __call__( - self, input: list[ifmpz_mod] | tuple[ifmpz_mod, ...] - ) -> list[fmpz_mod]: ... - def evaluate(self, input: ifmpz_mod) -> fmpz_mod: ... - def multipoint_evaluate(self, vals: Sequence[ifmpz_mod]) -> list[fmpz_mod]: ... - def compose(self, other: fmpz_mod_poly) -> fmpz_mod_poly: ... - def compose_mod( - self, other: ifmpz_mod_poly, modulus: ifmpz_mod_poly - ) -> fmpz_mod_poly: ... - def length(self) -> int: ... - def degree(self) -> int: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_gen(self) -> bool: ... - def is_constant(self) -> bool: ... - def constant_coefficient(self) -> fmpz_mod: ... - def leading_coefficient(self) -> fmpz_mod: ... - def reverse(self, degree: int | None = None) -> fmpz_mod_poly: ... - def truncate(self, n: int) -> fmpz_mod_poly: ... - def is_monic(self) -> bool: ... - def monic(self, check: bool = True) -> fmpz_mod_poly: ... - def is_irreducible(self) -> bool: ... - def is_squarefree(self) -> bool: ... - def square(self) -> fmpz_mod_poly: ... - def mul_mod( - self, other: ifmpz_mod_poly, modulus: ifmpz_mod_poly - ) -> fmpz_mod_poly: ... - def pow_mod( - self, e: int, modulus: ifmpz_mod_poly | None = None, / - ) -> fmpz_mod_poly: ... - def divmod(self, other: ifmpz_mod_poly) -> tuple[fmpz_mod, fmpz_mod_poly]: ... - def __divmod__(self, other: ifmpz_mod_poly) -> tuple[fmpz_mod_poly, fmpz_mod_poly]: ... - def __rdivmod__(self, other: ifmpz_mod_poly) -> tuple[fmpz_mod_poly, fmpz_mod_poly]: ... - def gcd(self, other: ifmpz_mod_poly) -> fmpz_mod_poly: ... - def xgcd( - self, other: ifmpz_mod_poly - ) -> tuple[fmpz_mod_poly, fmpz_mod_poly, fmpz_mod_poly]: ... - def derivative(self) -> fmpz_mod_poly: ... - def integral(self) -> fmpz_mod_poly: ... - def discriminant(self) -> fmpz_mod: ... - def radical(self) -> fmpz_mod_poly: ... - def inverse_mod(self, other: ifmpz_mod_poly) -> fmpz_mod_poly: ... - def inverse_series_trunc(self, n: int) -> fmpz_mod_poly: ... - def resultant(self, other: ifmpz_mod_poly) -> fmpz_mod: ... - def sqrt(self) -> fmpz_mod_poly: ... - def sqrt_trunc(self, n: int) -> fmpz_mod_poly: ... - def inverse_sqrt_trunc(self, n: int) -> fmpz_mod_poly: ... - def equal_trunc(self, other: object, n: int) -> bool: ... - def add_trunc(self, other: fmpz_mod_poly, n: int) -> fmpz_mod_poly: ... - def sub_trunc(self, other: fmpz_mod_poly, n: int) -> fmpz_mod_poly: ... - def mul_low(self, other: fmpz_mod_poly, n: int) -> fmpz_mod_poly: ... - def pow_trunc(self, e: int, n: int) -> fmpz_mod_poly: ... - def inflate(self, n: int) -> fmpz_mod_poly: ... - def deflate(self, n: int) -> fmpz_mod_poly: ... - def deflation(self) -> tuple[fmpz_mod_poly, int]: ... - def factor_squarefree(self) -> tuple[fmpz_mod, list[tuple[fmpz_mod_poly, int]]]: ... - def factor( - self, algorithm: str | None = None - ) -> tuple[fmpz_mod, list[tuple[fmpz_mod_poly, int]]]: ... - @overload - def roots( - self, multiplicities: Literal[True] = ... - ) -> list[tuple[fmpz_mod, int]]: ... - @overload - def roots(self, multiplicities: Literal[False]) -> list[fmpz_mod]: ... diff --git a/src/flint/types/fmpz_mod_poly.pyx b/src/flint/types/fmpz_mod_poly.pyx deleted file mode 100644 index 12820bbc..00000000 --- a/src/flint/types/fmpz_mod_poly.pyx +++ /dev/null @@ -1,1928 +0,0 @@ -from cpython.list cimport PyList_Size as PyList_GET_SIZE - -from flint.pyflint cimport global_random_state -from flint.flintlib.functions.fmpz_mod cimport fmpz_mod_neg, fmpz_mod_set_fmpz -from flint.flintlib.functions.fmpz_mod_poly cimport * -from flint.flintlib.functions.fmpz_mod_poly_factor cimport * -from flint.flintlib.functions.fmpz cimport( - fmpz_init, - fmpz_clear, - fmpz_is_one -) -from flint.types.fmpz_vec cimport fmpz_vec - -from flint.types.fmpz cimport fmpz, any_as_fmpz -from flint.types.fmpz_mod cimport fmpz_mod_ctx, fmpz_mod -from flint.types.fmpz_poly cimport fmpz_poly - -from flint.flint_base.flint_base cimport flint_poly -from flint.utils.typecheck cimport typecheck - -from flint.utils.flint_exceptions import DomainError - -cdef class fmpz_mod_poly_ctx: - r""" - Context object for creating :class:`~.fmpz_mod_poly` initialised - with a modulus :math:`N`. - - >>> fmpz_mod_poly_ctx(2**127 - 1) - fmpz_mod_poly_ctx(170141183460469231731687303715884105727) - - """ - def __cinit__(self): - pass - - def __dealloc__(self): - pass - - def __init__(self, mod): - # Allow context to be made from fmpz_mod_ctx - if typecheck(mod, fmpz_mod_ctx): - self.mod = mod - else: # Otherwise attempt to create context from moduli - self.mod = fmpz_mod_ctx(mod) - - def modulus(self): - """ - Return the modulus from the context as an ``fmpz`` - type - - >>> R = fmpz_mod_poly_ctx(2**127 - 1) - >>> R.modulus() - 170141183460469231731687303715884105727 - - """ - return self.mod.modulus() - - def is_prime(self): - """ - Return whether the modulus is prime - - >>> fmpz_mod_poly_ctx(2**127).is_prime() - False - >>> fmpz_mod_poly_ctx(2**127 - 1).is_prime() - True - """ - return self.mod.is_prime() - - def zero(self): - """ - Return the zero element of this polynomial ring - - >>> R = fmpz_mod_poly_ctx(163) - >>> R.zero() - 0 - """ - cdef fmpz_mod_poly res - res = self.new_ctype_poly() - fmpz_mod_poly_zero(res.val, self.mod.val) - return res - - def one(self): - """ - Return the one element of this polynomial ring - - >>> R = fmpz_mod_poly_ctx(163) - >>> R.one() - 1 - """ - cdef fmpz_mod_poly res - res = self.new_ctype_poly() - fmpz_mod_poly_one(res.val, self.mod.val) - return res - - def gen(self): - """ - Return the generator of the polynomial: `x` - - >>> R = fmpz_mod_poly_ctx(163) - >>> R.gen() - x - """ - cdef fmpz_mod_poly res - res = self.new_ctype_poly() - fmpz_mod_poly_set_coeff_ui(res.val, 1, 1, self.mod.val) - return res - - def random_element(self, degree=3, monic=False, irreducible=False): - """ - Return a random element of degree ``degree``. If ``monic`` is ``True``, - ensures the output is monic. If ``irreducible`` is ``True``, ensures - that the output is irreducible. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R.random_element() - >>> f.degree() - 3 - >>> f = R.random_element(degree=123) - >>> f.degree() - 123 - >>> f = R.random_element(monic=True) - >>> f.is_monic() - True - >>> f = R.random_element(degree=13, monic=True, irreducible=True) - >>> f.degree() - 13 - >>> f.is_monic() - True - >>> f.is_irreducible() - True - """ - cdef slong length - if not (isinstance(monic, bool) and isinstance(irreducible, bool)): - raise TypeError("Both 'monic' and 'irreducible' must be of type bool") - - length = degree + 1 - if length <= 0: - raise ValueError("The degree argument must be non-negative") - - cdef fmpz_mod_poly res - res = self.new_ctype_poly() - if (monic and irreducible): - fmpz_mod_poly_randtest_monic_irreducible( - res.val, global_random_state, length, self.mod.val - ) - elif monic: - fmpz_mod_poly_randtest_monic( - res.val, global_random_state, length, self.mod.val - ) - elif irreducible: - fmpz_mod_poly_randtest_irreducible( - res.val, global_random_state, length, self.mod.val - ) - else: - fmpz_mod_poly_randtest( - res.val, global_random_state, length, self.mod.val - ) - return res - - cdef set_list_as_fmpz_mod_poly(self, fmpz_mod_poly_t poly, val): - cdef long i, n - cdef fmpz_t x - - n = PyList_GET_SIZE(val) - fmpz_mod_poly_fit_length(poly, n, self.mod.val) - - # TODO: should we support conversion from nmod? - fmpz_init(x) - for i in range(n): - if typecheck(val[i], fmpz_mod): - if self.mod != ((val[i])).ctx: - raise ValueError("moduli must match") - fmpz_mod_poly_set_coeff_fmpz( - poly, i, ((val[i])).val, self.mod.val - ) - elif typecheck(val[i], fmpz): - fmpz_mod_poly_set_coeff_fmpz( - poly, i, ((val[i])).val, self.mod.val - ) - else: - val_fmpz = any_as_fmpz(val[i]) - if val_fmpz is NotImplemented: - fmpz_clear(x) - raise TypeError("unsupported coefficient in list") - fmpz_mod_poly_set_coeff_fmpz( - poly, i, ((val_fmpz)).val, self.mod.val - ) - fmpz_clear(x) - return 0 - - cdef set_any_as_fmpz_mod_poly(self, fmpz_mod_poly_t poly, obj): - # Set val from fmpz_mod_poly - if typecheck(obj, fmpz_mod_poly): - if self != (obj).ctx: - raise ValueError("moduli must match") - fmpz_mod_poly_set( - poly, (obj).val, self.mod.val - ) - return 0 - - # Convert fmpz_mod to constant poly - if typecheck(obj, fmpz_mod): - if self.mod != (obj).ctx: - raise ValueError("moduli must match") - fmpz_mod_poly_set_fmpz( - poly, (obj).val, self.mod.val - ) - return 0 - - # Reduced fmpz_poly modulo mod - if typecheck(obj, fmpz_poly): - fmpz_mod_poly_set_fmpz_poly( - poly, (obj).val, self.mod.val - ) - return 0 - - # Lastly try and convert to an fmpz - obj = any_as_fmpz(obj) - if obj is NotImplemented: - return NotImplemented - fmpz_mod_poly_set_fmpz( - poly, (obj).val, self.mod.val - ) - return 0 - - cdef any_as_fmpz_mod_poly(self, obj): - # Convert fmpz_mod_poly - if typecheck(obj, fmpz_mod_poly): - if self != (obj).ctx: - raise ValueError("moduli must match") - return obj - - cdef fmpz_mod_poly res - res = self.new_ctype_poly() - check = self.set_any_as_fmpz_mod_poly(res.val, obj) - if check is NotImplemented: - return NotImplemented - - return res - - cdef new_ctype_poly(self): - return fmpz_mod_poly.__new__(fmpz_mod_poly, None, self) - - def __eq__(self, other): - # Most often, we expect both `fmpz_mod_poly` to be pointing - # to the same ctx, so this seems the fastest way to check - if self is other: - return True - - # If they're not the same object in memory, they may have the - # same modulus, which is good enough - if typecheck(other, fmpz_mod_poly_ctx): - return self.mod == (other).mod - return False - - def __hash__(self): - return hash(self.modulus()) - - def __str__(self): - return f"Context for fmpz_mod_poly with modulus: {self.modulus()}" - - def __repr__(self): - return f"fmpz_mod_poly_ctx({self.modulus()})" - - def __call__(self, val): - return fmpz_mod_poly(val, self) - - def minpoly(self, vals): - """ - Returns a minimal generating polynomial for sequence `vals`. - - A minimal generating polynomial is a monic polynomial, of minimal degree `d`, - that annihilates any consecutive `d+1` terms in seq. - - Assumes that the modulus is prime. - - >>> R = fmpz_mod_poly_ctx(163) - >>> R.minpoly([1,1,2,3,5,8]) - x^2 + 162*x + 162 - >>> R.minpoly([2,4,6,8,10]) - x^2 + 161*x + 1 - """ - cdef fmpz_mod_poly res - - if not self.is_prime(): - raise NotImplementedError("minpoly algorithm assumes that the modulus is prime") - - if not isinstance(vals, (list, tuple)): - raise TypeError("Input must be a list or tuple of points") - - n = len(vals) - xs = fmpz_vec(n) - for i in range(n): - check = self.mod.set_any_as_fmpz_mod(&xs.val[i], vals[i]) - if check is NotImplemented: - raise TypeError(f"Unable to cast {vals[i]} to an 'fmpz_mod'") - - res = self.new_ctype_poly() - fmpz_mod_poly_minpoly(res.val, xs.val, n, self.mod.val) - - return res - -cdef class fmpz_mod_poly(flint_poly): - """ - The *fmpz_mod_poly* type represents univariate polynomials - over integer modulo an arbitrary-size modulus. - For wordsize modulus, see :class:`~.nmod_poly`. - - An *fmpz_mod_poly* element is constructed from an :class:`~.fmpz_mod_poly_ctx` - either by passing it as an argument to the type, or - by directly calling the context: - - >>> fmpz_mod_poly([1,-2,3], fmpz_mod_poly_ctx(2**127 - 1)) - 3*x^2 + 170141183460469231731687303715884105725*x + 1 - >>> R = fmpz_mod_poly_ctx(2**127 - 1) - >>> R([4,5,6]) - 6*x^2 + 5*x + 4 - - """ - def __cinit__(self, val, ctx): - if not typecheck(ctx, fmpz_mod_poly_ctx): - raise TypeError - self.ctx = ctx - fmpz_mod_poly_init(self.val, self.ctx.mod.val) - - def __dealloc__(self): - if self.ctx is not None: - fmpz_mod_poly_clear(self.val, self.ctx.mod.val) - - def __init__(self, val, ctx): - if typecheck(val, list): - self.ctx.set_list_as_fmpz_mod_poly(self.val, val) - return - - check = self.ctx.set_any_as_fmpz_mod_poly(self.val, val) - if check is NotImplemented: - raise TypeError - - def modulus(self): - return self.ctx.modulus() - - def context(self): - return self.ctx - - def repr(self): - coeffs_str = ", ".join(map(str, self.coeffs())) - return f"fmpz_mod_poly([{coeffs_str}], fmpz_mod_poly_ctx({self.ctx.modulus()}))" - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpz_mod_poly res - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_neg(res.val, self.val, self.ctx.mod.val) - return res - - def __add__(self, other): - cdef fmpz_mod_poly res - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - return other - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_add( - res.val, self.val, (other).val, self.ctx.mod.val - ) - return res - - def __radd__(self, other): - return self.__add__(other) - - @staticmethod - def _sub_(left, right): - cdef fmpz_mod_poly res - - # Case when left and right are already fmpz_mod_poly - if typecheck(left, fmpz_mod_poly) and typecheck(right, fmpz_mod_poly): - if not (left).ctx == (right).ctx: - raise ValueError("moduli must match") - - # Case when right is not fmpz_mod_poly, try to convert to fmpz - elif typecheck(left, fmpz_mod_poly): - right = (left).ctx.any_as_fmpz_mod_poly(right) - if right is NotImplemented: - return NotImplemented - - # Case when left is not fmpz_mod_poly, try to convert to fmpz - else: - left = (right).ctx.any_as_fmpz_mod_poly(left) - if left is NotImplemented: - return NotImplemented - - res = (left).ctx.new_ctype_poly() - fmpz_mod_poly_sub( - res.val, (left).val, (right).val, res.ctx.mod.val - ) - return res - - def __sub__(s, t): - return fmpz_mod_poly._sub_(s, t) - - def __rsub__(s, t): - return fmpz_mod_poly._sub_(t, s) - - def scalar_mul(self, other): - """ - Returns the polynomial equal to ``self`` scaled by the input - ``other`` - """ - cdef fmpz_mod_poly res - - other = self.ctx.mod.any_as_fmpz_mod(other) - if other is NotImplemented: - raise TypeError - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_scalar_mul_fmpz( - res.val, self.val, (other).val, self.ctx.mod.val - ) - return res - - def __mul__(self, other): - cdef fmpz_mod_poly res - - # If input is a scalar, use fastwe multiplication - if (typecheck(other, int) or typecheck(other, fmpz) or typecheck(other, fmpz_mod)): - return self.scalar_mul(other) - - # Otherwise perform polynomial multiplication - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - return other - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_mul( - res.val, self.val, (other).val, self.ctx.mod.val - ) - return res - - def __rmul__(self, other): - return self.__mul__(other) - - def _div_(self, other): - cdef fmpz_mod_poly res - - other = self.ctx.mod.any_as_fmpz_mod(other) - if other is NotImplemented: - return NotImplemented - - if other == 0: - raise ZeroDivisionError("Cannot divide by zero") - elif not other.is_unit(): - raise DomainError(f"Cannot divide by {other} modulo {self.ctx.modulus()}") - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_scalar_div_fmpz( - res.val, self.val, (other).val, res.ctx.mod.val - ) - - return res - - def __truediv__(s, t): - t2 = s.ctx.mod.any_as_fmpz_mod(t) - if t2 is not NotImplemented: - return s._div_(t2) - t2 = s.ctx.any_as_fmpz_mod_poly(t) - if t2 is NotImplemented: - return NotImplemented - return s.exact_division(t2) - - def __rtruediv__(s, t): - t = s.ctx.any_as_fmpz_mod_poly(t) - if t is NotImplemented: - return NotImplemented - return t.exact_division(s) - - def exact_division(self, right): - """ - Attempt to compute the exact quotient of self with other - Raises a value error if division without remainder is not - possible. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,1]) - >>> g = R([1,1]) - >>> f.exact_division(g) - x + 1 - """ - cdef bint check - cdef fmpz_mod_poly res - - # Case when right is not fmpz_mod_poly, try to convert to fmpz - right = self.ctx.any_as_fmpz_mod_poly(right) - if right is NotImplemented: - raise TypeError(f"Cannot convert {right} to 'fmpz_mod_poly' type.") - - if right == 0: - raise ZeroDivisionError("Cannot divide by zero") - - res = self.ctx.new_ctype_poly() - check = fmpz_mod_poly_divides( - res.val, self.val, (right).val, res.ctx.mod.val - ) - if check == 0: - raise DomainError( - f"{right} does not divide {self}" - ) - - return res - - @staticmethod - def _floordiv_(left, right): - cdef fmpz_mod_poly res - - # Case when left and right are already fmpz_mod_poly - if typecheck(left, fmpz_mod_poly) and typecheck(right, fmpz_mod_poly): - if not (left).ctx == (right).ctx: - raise ValueError("moduli must match") - - # Case when right is not fmpz_mod_poly, try to convert to fmpz - elif typecheck(left, fmpz_mod_poly): - right = (left).ctx.any_as_fmpz_mod_poly(right) - if right is NotImplemented: - return NotImplemented - - # Case when left is not fmpz_mod_poly, try to convert to fmpz - else: - left = (right).ctx.any_as_fmpz_mod_poly(left) - if left is NotImplemented: - return NotImplemented - - lc = right.leading_coefficient() - - if lc.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - elif not lc.is_unit(): - raise DomainError(f"The leading term of {right} must be a unit modulo N") - - res = (left).ctx.new_ctype_poly() - fmpz_mod_poly_div( - res.val, (left).val, (right).val, res.ctx.mod.val - ) - return res - - def __floordiv__(self, other): - return fmpz_mod_poly._floordiv_(self, other) - - def __rfloordiv__(self, other): - return fmpz_mod_poly._floordiv_(other, self) - - def __pow__(self, e, mod=None): - if mod is not None: - return self.pow_mod(e, mod) - - cdef fmpz_mod_poly res - if e < 0: - self = 1 / self - e = -e - - cdef ulong e_ulong = e - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_pow( - res.val, self.val, e_ulong, self.ctx.mod.val - ) - return res - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([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 - - """ - cdef fmpz_mod_poly res - res = self.ctx.new_ctype_poly() - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - - if n > 0: - fmpz_mod_poly_shift_left( - res.val, self.val, n, self.ctx.mod.val - ) - else: # do nothing, just copy self - fmpz_mod_poly_set( - res.val, self.val, self.ctx.mod.val - ) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([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 - """ - cdef fmpz_mod_poly res - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - - res = self.ctx.new_ctype_poly() - - if n > 0: - fmpz_mod_poly_shift_right( - res.val, self.val, n, self.ctx.mod.val - ) - else: # do nothing, just copy self - fmpz_mod_poly_set( - res.val, self.val, self.ctx.mod.val - ) - - return res - - @staticmethod - def _mod_(left, right): - cdef fmpz_t f - cdef fmpz_mod_poly res - - # Case when left and right are already fmpz_mod_poly - if typecheck(left, fmpz_mod_poly) and typecheck(right, fmpz_mod_poly): - if not (left).ctx == (right).ctx: - raise ValueError("moduli must match") - - # Case when right is not fmpz_mod_poly, try to convert to fmpz - elif typecheck(left, fmpz_mod_poly): - right = (left).ctx.any_as_fmpz_mod_poly(right) - if right is NotImplemented: - return NotImplemented - - # Case when left is not fmpz_mod_poly, try to convert to fmpz - else: - left = (right).ctx.any_as_fmpz_mod_poly(left) - if left is NotImplemented: - return NotImplemented - - if right == 0: - raise ZeroDivisionError("Cannot reduce modulo zero") - - res = (left).ctx.new_ctype_poly() - fmpz_init(f) - fmpz_mod_poly_rem_f( - f, res.val, (left).val, (right).val, res.ctx.mod.val - ) - if not fmpz_is_one(f): - fmpz_clear(f) - raise DomainError( - f"Cannot compute remainder of {left} modulo {right}" - ) - - return res - - def __mod__(s, t): - return fmpz_mod_poly._mod_(s, t) - - def __rmod__(s, t): - return fmpz_mod_poly._mod_(t, s) - - def __richcmp__(self, other, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("fmpz_mod_poly cannot be ordered") - - if not typecheck(other, fmpz_mod_poly): - other = self.ctx.any_as_fmpz_mod_poly(other) - - if typecheck(other, fmpz_mod_poly): - res = (self.ctx == (other).ctx) and \ - fmpz_mod_poly_equal(self.val, (other).val, self.ctx.mod.val) - if op == 2: - return res - else: - return not res - else: - return NotImplemented - - def __getitem__(self, long i): - cdef fmpz_mod x - x = fmpz_mod.__new__(fmpz_mod) - x.ctx = self.ctx.mod - if i < 0: - return x - fmpz_mod_poly_get_coeff_fmpz( - x.val, self.val, i, self.ctx.mod.val - ) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - v = self.ctx.mod.any_as_fmpz_mod(x) - if v is NotImplemented: - raise TypeError - fmpz_mod_poly_set_coeff_fmpz( - self.val, i, (v).val, self.ctx.mod.val - ) - - def __len__(self): - return fmpz_mod_poly_length(self.val, self.ctx.mod.val) - - def __hash__(self): - return hash(tuple(self.coeffs())) - - def __call__(self, input): - if typecheck(input, fmpz_mod_poly): - return self.compose(input) - elif isinstance(input, (list, tuple)): - return self.multipoint_evaluate(input) - else: - return self.evaluate(input) - - def evaluate(self, input): - """ - Evaluate ``self`` at a point in the base ring. This is - the same as calling the polynomial directly. To evaluate - a list of points, use ``multiploint_evaluate``. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5,6]) - >>> f.evaluate(-1) - fmpz_mod(160, 163) - >>> f.evaluate(-1) == f(-1) - True - """ - cdef fmpz_mod res - val = self.ctx.mod.any_as_fmpz_mod(input) - if val is NotImplemented: - raise TypeError(f"Cannot evaluate the polynomial with input: {input}") - - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx.mod - fmpz_mod_poly_evaluate_fmpz(res.val, self.val, (val).val, self.ctx.mod.val) - return res - - def multipoint_evaluate(self, vals): - """ - Returns a list of values computed from evaluating - ``self`` at the ``n`` values given in the vector ``val`` - - TODO: We could allow passing as an optional input the - subproduct tree, which would allow for faster, repeated - multipoint evaluations - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> [f(x) for x in [-1,-2,-3]] - [fmpz_mod(3, 163), fmpz_mod(57, 163), fmpz_mod(156, 163)] - >>> f.multipoint_evaluate([-1,-2,-3]) - [fmpz_mod(3, 163), fmpz_mod(57, 163), fmpz_mod(156, 163)] - """ - cdef fmpz_mod f - - if not isinstance(vals, (list, tuple)): - raise TypeError("Input must be a list of points") - - n = len(vals) - xs = fmpz_vec(n) - for i in range(n): - check = self.ctx.mod.set_any_as_fmpz_mod(&xs.val[i], vals[i]) - if check is NotImplemented: - raise TypeError(f"Unable to cast {vals[i]} to an 'fmpz_mod'") - - # Call for multipoint eval, iterative horner will be used - # for small arrays (len < 32) and a fast eval for larger ones - # using a subproduct tree - ys = fmpz_vec(n) - fmpz_mod_poly_evaluate_fmpz_vec(ys.val, self.val, xs.val, n, self.ctx.mod.val) - - evaluations = [] - for i in range(n): - f = fmpz_mod.__new__(fmpz_mod) - f.ctx = self.ctx.mod - fmpz_mod_set_fmpz(f.val, &ys.val[i], self.ctx.mod.val) - evaluations.append(f) - - return evaluations - - def compose(self, other): - """ - Returns the composition of two polynomials - - To be precise about the order of composition, given ``self``, and ``other`` - by `f(x)`, `g(x)`, returns `f(g(x))`. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> g = R([0,0,1]) - >>> f.compose(g) - 3*x^4 + 2*x^2 + 1 - >>> g.compose(f) - 9*x^4 + 12*x^3 + 10*x^2 + 4*x + 1 - """ - cdef fmpz_mod_poly res - val = self.ctx.any_as_fmpz_mod_poly(other) - if val is NotImplemented: - raise TypeError(f"Cannot compose the polynomial with input: {other}") - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_compose(res.val, self.val, (val).val, self.ctx.mod.val) - return res - - def compose_mod(self, other, modulus): - r""" - Returns the composition of two polynomials modulo a third. - - To be precise about the order of composition, given ``self``, and ``other`` - and ``modulus`` by `f(x)`, `g(x)` and `h(x)`, returns `f(g(x)) \mod h(x)`. - We require that `h(x)` is non-zero. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> g = R([3,2,1]) - >>> h = R([1,0,1,0,1]) - >>> f.compose_mod(g, h) - 63*x^3 + 100*x^2 + 17*x + 63 - >>> g.compose_mod(f, h) - 147*x^3 + 159*x^2 + 4*x + 7 - """ - cdef fmpz_mod_poly res - val = self.ctx.any_as_fmpz_mod_poly(other) - if val is NotImplemented: - raise TypeError(f"cannot compose the polynomial with input: {other}") - - h = self.ctx.any_as_fmpz_mod_poly(modulus) - if h is NotImplemented: - raise TypeError(f"cannot reduce the polynomial with input: {modulus}") - - if h.is_zero(): - raise ZeroDivisionError("cannot reduce modulo zero") - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_compose_mod(res.val, self.val, (val).val, (h).val, self.ctx.mod.val) - return res - - cpdef long length(self): - """ - Return the length of the polynomial - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.length() - 3 - - """ - return fmpz_mod_poly_length(self.val, self.ctx.mod.val) - - cpdef long degree(self): - """ - Return the degree of the polynomial - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.degree() - 2 - - """ - return fmpz_mod_poly_degree(self.val, self.ctx.mod.val) - - def is_zero(self): - """ - Return ``True`` if the polynomial is the zero polynomial - and ``False`` otherwise - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R(0) - >>> f.is_zero() - True - """ - return 0 != fmpz_mod_poly_is_zero(self.val, self.ctx.mod.val) - - def is_one(self): - """ - Return ``True`` if the polynomial is equal to one - and ``False`` otherwise - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R(1) - >>> f.is_one() - True - """ - return 0 != fmpz_mod_poly_is_one(self.val, self.ctx.mod.val) - - def is_gen(self): - """ - Return ``True`` if the polynomial is the generator - of the polynomial, `x`, and ``False`` otherwise - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([0,1]) - >>> f.is_gen() - True - """ - return 0 != fmpz_mod_poly_is_gen(self.val, self.ctx.mod.val) - - def is_constant(self): - """ - Return ``True`` if this is a constant polynomial. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> x.is_constant() - False - >>> R(123).is_constant() - True - """ - return self.degree() <= 0 - - def constant_coefficient(self): - """ - Return the constant coefficient of this polynomial. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.constant_coefficient() - fmpz_mod(1, 163) - """ - return self[0] - - # XXX: Methods like leading_coefficient() that are generic should be moved - # to the flint_poly base class rather than defined here. - - def leading_coefficient(self): - """ - Return the leading coefficient of this polynomial. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.leading_coefficient() - fmpz_mod(3, 163) - """ - # XXX: This is a workaround for a Cython/PyPy bug: - # https://github.com/flintlib/python-flint/issues/74 - # https://github.com/cython/cython/issues/5776 - d = self.degree() - if d < 0: - return self.ctx.mod.zero() - return self[self.degree()] - - def reverse(self, degree=None): - """ - Return a polynomial with the coefficients of this polynomial - reversed. - - If ``degree`` is not None, the output polynomial will be zero-padded - or truncated before being reversed. NOTE: degree must be non-negative. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> f.reverse() - x^4 + 2*x^3 + 3*x^2 + 4*x + 5 - >>> f.reverse(degree=1) - x + 2 - >>> f.reverse(degree=100) - x^100 + 2*x^99 + 3*x^98 + 4*x^97 + 5*x^96 - """ - cdef fmpz_mod_poly res - cdef slong d - - if degree is not None: - d = degree - if d != degree or d < 0: - raise ValueError(f"degree argument must be a non-negative integer, got {degree}") - else: - d = fmpz_mod_poly_degree(self.val, self.ctx.mod.val) - - length = d + 1 - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_reverse(res.val, self.val, length, self.ctx.mod.val) - return res - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then a copy of ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.truncate(3) == f - True - >>> f.truncate(2) - 2*x + 1 - >>> f.truncate(1) - 1 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - - """ - cdef fmpz_mod_poly res - - length = fmpz_mod_poly_degree(self.val, self.ctx.mod.val) - res = self.ctx.new_ctype_poly() - - if n <= 0: # return zero - return res - elif n > length: # do nothing - fmpz_mod_poly_set( - res.val, self.val, self.ctx.mod.val - ) - else: - fmpz_mod_poly_set_trunc( - res.val, self.val, n, self.ctx.mod.val - ) - return res - - def is_monic(self): - """ - Return whether this polynomial is monic. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = x**2 + 5*x + 3 - >>> f.is_monic() - True - >>> f = 5*x**2 + x + 3 - >>> f.is_monic() - False - """ - return self.leading_coefficient().is_one() - - def monic(self, check=True): - """ - Return this polynomial divided by its leading coefficient. - - If ``check`` is True, raises ValueError if the leading coefficient - is not invertible modulo N. If ``check`` is False and the leading - coefficient is not invertible, the output is undefined. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.monic() - x^2 + 55*x + 109 - """ - cdef fmpz_mod_poly res - cdef fmpz_t f - - res = self.ctx.new_ctype_poly() - if not check: - fmpz_mod_poly_make_monic( - res.val, self.val, self.ctx.mod.val - ) - else: - fmpz_init(f) - fmpz_mod_poly_make_monic_f( - f, res.val, self.val, self.ctx.mod.val - ) - if not fmpz_is_one(f): - fmpz_clear(f) - raise ValueError("Leading coefficient is not invertible") - return res - - def is_irreducible(self): - """ - Return whether this polynomial is irreducible. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = x**2 + 5*x + 3 - >>> f.is_irreducible() - True - >>> f = x**2 + x + 3 - >>> f.is_irreducible() - False - """ - return 1 == fmpz_mod_poly_is_irreducible(self.val, self.ctx.mod.val) - - def is_squarefree(self): - """ - Return whether this polynomial is squarefree. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = (x + 1)**2 * (x + 3) - >>> f.is_squarefree() - False - >>> f = (x + 1) * (x + 3) - >>> f.is_squarefree() - True - - """ - return 1 == fmpz_mod_poly_is_squarefree(self.val, self.ctx.mod.val) - - def square(self): - """ - Returns the square of ``self`` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.square() - 9*x^4 + 12*x^3 + 10*x^2 + 4*x + 1 - """ - cdef fmpz_mod_poly res - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_sqr( - res.val, self.val, self.ctx.mod.val - ) - return res - - def mul_mod(self, other, modulus): - """ - Computes the multiplication of ``self`` with ``other`` - modulo the polynomial ``modulus`` - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> g = 43*x**6 + 91*x**5 + 77*x**4 + 113*x**3 + 71*x**2 + 132*x + 60 - >>> mod = x**4 + 93*x**3 + 78*x**2 + 72*x + 149 - >>> - >>> f.mul_mod(g, mod) - 106*x^3 + 44*x^2 + 53*x + 77 - """ - cdef fmpz_mod_poly res - - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - modulus = self.ctx.any_as_fmpz_mod_poly(modulus) - if modulus is NotImplemented: - raise TypeError(f"Cannot interpret {modulus} as a polynomial") - - res = self.ctx.new_ctype_poly() - - fmpz_mod_poly_mulmod( - res.val, self.val, (other).val, (modulus).val, res.ctx.mod.val - ) - return res - - def pow_mod(self, e, modulus, mod_rev_inv=None): - r""" - Returns ``self`` raised to the power ``e`` modulo ``modulus``: - :math:`f^e \mod g`/ - - ``mod_rev_inv`` is the inverse of the reverse of the modulus, - precomputing it and passing it to ``pow_mod()`` can optimise - powering of polynomials with large exponents. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> g = 43*x**6 + 91*x**5 + 77*x**4 + 113*x**3 + 71*x**2 + 132*x + 60 - >>> mod = x**4 + 93*x**3 + 78*x**2 + 72*x + 149 - >>> - >>> f.pow_mod(123, mod) - 3*x^3 + 25*x^2 + 115*x + 161 - >>> f.pow_mod(2**64, mod) - 52*x^3 + 96*x^2 + 136*x + 9 - >>> mod_rev_inv = mod.reverse().inverse_series_trunc(4) - >>> f.pow_mod(2**64, mod, mod_rev_inv) - 52*x^3 + 96*x^2 + 136*x + 9 - """ - cdef fmpz_mod_poly res - - if e < 0: - raise ValueError("Exponent must be non-negative") - - modulus = self.ctx.any_as_fmpz_mod_poly(modulus) - if modulus is NotImplemented: - raise TypeError(f"Cannot interpret {modulus} as a polynomial") - - # Output polynomial - res = self.ctx.new_ctype_poly() - - # For small exponents, use a simple binary exponentiation method - if e.bit_length() < 32: - fmpz_mod_poly_powmod_ui_binexp( - res.val, self.val, e, (modulus).val, res.ctx.mod.val - ) - return res - - # For larger exponents we need to cast e to an fmpz first - e_fmpz = any_as_fmpz(e) - if e_fmpz is NotImplemented: - raise TypeError(f"exponent cannot be cast to an fmpz type: {e}") - - # To optimise powering, we precompute the inverse of the reverse of the modulus - if mod_rev_inv is not None: - mod_rev_inv = self.ctx.any_as_fmpz_mod_poly(mod_rev_inv) - if mod_rev_inv is NotImplemented: - raise TypeError(f"Cannot interpret {mod_rev_inv} as a polynomial") - else: - mod_rev_inv = modulus.reverse().inverse_series_trunc(modulus.length()) - - # Use windowed exponentiation optimisation when self = x - if self.is_gen(): - fmpz_mod_poly_powmod_x_fmpz_preinv( - res.val, (e_fmpz).val, (modulus).val, (mod_rev_inv).val, res.ctx.mod.val - ) - return res - - # Otherwise using binary exponentiation for all other inputs - fmpz_mod_poly_powmod_fmpz_binexp_preinv( - res.val, self.val, (e_fmpz).val, (modulus).val, (mod_rev_inv).val, res.ctx.mod.val - ) - return res - - def divmod(self, other): - """ - Return `Q`, `R` such that for ``self`` = `F` and ``other`` = `G`, - `F = Q*G + R` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([123, 129, 63, 14, 51, 76, 133]) - >>> g = R([106, 134, 32, 41, 158, 115, 115]) - >>> f.divmod(g) - (21, 106*x^5 + 156*x^4 + 131*x^3 + 43*x^2 + 86*x + 16) - """ - cdef fmpz_t f - cdef fmpz_mod_poly Q, R - - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - if other == 0: - raise ZeroDivisionError(f"Cannot compute divmod as {other =}") - - Q = self.ctx.new_ctype_poly() - R = self.ctx.new_ctype_poly() - - fmpz_init(f) - fmpz_mod_poly_divrem_f( - f, Q.val, R.val, self.val, (other).val, self.ctx.mod.val - ) - if not fmpz_is_one(f): - fmpz_clear(f) - raise ValueError( - f"Cannot compute divmod of {self} with {other}" - ) - - return Q, R - - def __divmod__(self, other): - return self.divmod(other) - - def __rdivmod__(self, other): - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - return other - return other.divmod(self) - - def gcd(self, other): - """ - Return the greatest common divisor of self and other. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = x*(x + 1) - >>> f.gcd(x+1) - x + 1 - >>> f.gcd(x*x) - x - - """ - cdef fmpz_mod_poly res - - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - if not self.ctx.is_prime(): - raise DomainError("gcd algorithm assumes that the modulus is prime") - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_gcd( - res.val, self.val, (other).val, self.ctx.mod.val - ) - return res - - def xgcd(self, other): - r""" - Computes the extended gcd of self and other: (`G`, `S`, `T`) - where `G` is the ``gcd(self, other)`` and `S`, `T` are such that: - - :math:`G = \textrm{self}*S + \textrm{other}*T` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([143, 19, 37, 138, 102, 127, 95]) - >>> g = R([139, 9, 35, 154, 87, 120, 24]) - >>> f.xgcd(g) - (x^3 + 128*x^2 + 123*x + 91, 17*x^2 + 49*x + 104, 21*x^2 + 5*x + 25) - - """ - cdef fmpz_mod_poly G, S, T - cdef fmpz_t f - - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - G = self.ctx.new_ctype_poly() - S = self.ctx.new_ctype_poly() - T = self.ctx.new_ctype_poly() - - fmpz_init(f) - fmpz_mod_poly_xgcd_f( - f, G.val, S.val, T.val, self.val, (other).val, self.ctx.mod.val - ) - if not fmpz_is_one(f): - fmpz_clear(f) - raise ValueError( - f"Cannot compute xgcd of {self} with {other}" - ) - return (G, S, T) - - def derivative(self): - """ - The formal derivative of this polynomial - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 111*x**4 + 58*x**3 + 98*x**2 + 117*x + 7 - >>> f.derivative() - 118*x^3 + 11*x^2 + 33*x + 117 - - """ - cdef fmpz_mod_poly res - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_derivative( - res.val, self.val, self.ctx.mod.val - ) - return res - - def integral(self): - """ - The formal integral of this polynomial. The constant term - from boundary conditions is picked to be zero. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 118*x**3 + 11*x**2 + 33*x + 117 - >>> f.integral() - 111*x^4 + 58*x^3 + 98*x^2 + 117*x - - """ - new_coeffs = [0] + [c/n for n, c in enumerate(self.coeffs(), 1)] - return self.ctx(new_coeffs) - - def discriminant(self): - """ - Return the discriminant of ``self``. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 6*x**4 + 7*x**3 + 7*x**2 + 8*x + 6 - >>> f.discriminant() - fmpz_mod(50, 163) - - """ - cdef fmpz_mod res - - if not self.ctx.is_prime(): - raise NotImplementedError("discriminant algorithm assumes that the base is a field") - - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx.mod - fmpz_mod_poly_discriminant( - res.val, self.val, self.ctx.mod.val - ) - return res - - def radical(self): - """ - Return the radical of ``self``, the product of the irreducible - factors of the polynomial. This is also referred to as the - square-free part of the polynomial. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = (x + 1)**3 * (x + 2) - >>> f.radical() - x^2 + 3*x + 2 - - """ - if not self.ctx.is_prime(): - raise NotImplementedError("radical algorithm assumes that the base is a field") - - return self.exact_division(self.gcd(self.derivative())) - - def inverse_mod(self, other): - """ - Returns the inverse of ``self`` modulo ``other`` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = f = R([123, 129, 63, 14, 51, 76, 133]) - >>> f = R([123, 129, 63, 14, 51, 76, 133]) - >>> g = R([139, 9, 35, 154, 87, 120, 24]) - >>> f.inverse_mod(g) - 41*x^5 + 121*x^4 + 47*x^3 + 41*x^2 + 6*x + 5 - """ - cdef fmpz_mod_poly res - cdef fmpz_t f - - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - res = self.ctx.new_ctype_poly() - res.ctx = self.ctx - fmpz_init(f) - fmpz_mod_poly_invmod_f( - f, res.val, self.val, (other).val, res.ctx.mod.val - ) - if not fmpz_is_one(f): - fmpz_clear(f) - raise ValueError( - f"Cannot compute inverse of {self} modulo {other}" - ) - return res - - def inverse_series_trunc(self, slong n): - """ - Returns the inverse of ``self`` modulo `x^n`. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([123, 129, 63, 14, 51, 76, 133]) - >>> f.inverse_series_trunc(3) - 159*x^2 + 151*x + 110 - >>> f.inverse_series_trunc(4) - 23*x^3 + 159*x^2 + 151*x + 110 - >>> f.inverse_series_trunc(5) - 45*x^4 + 23*x^3 + 159*x^2 + 151*x + 110 - """ - cdef fmpz_t f - cdef fmpz_mod_poly res - - res = self.ctx.new_ctype_poly() - fmpz_init(f) - fmpz_mod_poly_inv_series_f( - f, res.val, self.val, n, res.ctx.mod.val - ) - if not fmpz_is_one(f): - fmpz_clear(f) - raise ValueError( - f"Cannot compute inverse series of {self} modulo x^{n}" - ) - return res - - def resultant(self, other): - """ - Returns the resultant of ``self`` with ``other``. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> g = R([9,8,7]) - >>> f.resultant(g) - fmpz_mod(57, 163) - - """ - cdef fmpz_mod res - - if not self.ctx.mod.is_prime(): - raise ValueError("cannot compute fmpz_mod_poly resultants with composite moduli") - - other = self.ctx.any_as_fmpz_mod_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - res = fmpz_mod.__new__(fmpz_mod) - res.ctx = self.ctx.mod - fmpz_mod_poly_resultant( - res.val, self.val, (other).val, self.ctx.mod.val - ) - return res - - def sqrt(self): - """ - If ``self`` is a perfect square, compute the square root - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,1]) - >>> (f*f).sqrt() - x + 1 - - """ - cdef fmpz_mod_poly res - cdef int check - - if not self.ctx.is_prime(): - raise DomainError("sqrt algorithm assumes that the modulus is prime") - - res = self.ctx.new_ctype_poly() - check = fmpz_mod_poly_sqrt( - res.val, self.val, res.ctx.mod.val - ) - if check != 1: - raise DomainError( - f"Cannot compute square-root {self}" - ) - return res - - def sqrt_trunc(self, slong n): - """ - Returns the squareroot of ``self`` modulo `x^n`. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = R([1,2,3]) - >>> h = f.sqrt_trunc(5) - >>> h - 82*x^4 + 162*x^3 + x^2 + x + 1 - >>> h.mul_mod(h, x**5) == f - True - - """ - cdef fmpz_mod_poly res - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_sqrt_series( - res.val, self.val, n, res.ctx.mod.val - ) - return res - - def inverse_sqrt_trunc(self, slong n): - """ - Returns the inverse squareroot of ``self`` modulo `x^n`. - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> h = f.inverse_sqrt_trunc(5) - >>> h - 78*x^4 + 2*x^3 + 162*x + 1 - >>> (h*h).inverse_series_trunc(5) == f - True - """ - cdef fmpz_mod_poly res - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_invsqrt_series( - res.val, self.val, n, res.ctx.mod.val - ) - return res - - def equal_trunc(self, other, slong n): - """ - Returns if two polynomials are equal when truncated to the first ``n`` terms - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> h = R([1,2,3]) - >>> f.equal_trunc(h, 3) - True - >>> f.equal_trunc(h, 4) - False - """ - # Only allow comparison with other fmpz_mod_poly - if not typecheck(other, fmpz_mod_poly): - return False - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - return False - - return 1 == fmpz_mod_poly_equal_trunc(self.val, other_c.val, n, self.ctx.mod.val) - - def add_trunc(self, other, slong n): - """ - Truncate ``self`` and ``other`` to polynomials of length ``n`` and return their sum - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> h = R([1,2,3]) - >>> f.add_trunc(h, 2) - 4*x + 2 - >>> f.add_trunc(h, 3) - 6*x^2 + 4*x + 2 - """ - # Only allow addition with other fmpz_mod_poly - if not typecheck(other, fmpz_mod_poly): - raise TypeError("other polynomial must be of type fmpz_mod_poly") - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - raise ValueError("other polynomial's context does not match") - - cdef fmpz_mod_poly res - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_add_series( - res.val, self.val, other_c.val, n, res.ctx.mod.val - ) - return res - - def sub_trunc(self, other, slong n): - """ - Truncate ``self`` and ``other`` to polynomials of length ``n`` and return their difference - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([2,3,5,7,11]) - >>> h = R([1,2,4,8,16]) - >>> f.sub_trunc(h, 2) - x + 1 - >>> f.sub_trunc(h, 4) - 162*x^3 + x^2 + x + 1 - """ - # Only allow subtraction with other fmpz_mod_poly - if not typecheck(other, fmpz_mod_poly): - raise TypeError("other polynomial must be of type fmpz_mod_poly") - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - raise ValueError("other polynomial's context does not match") - - cdef fmpz_mod_poly res - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_sub_series( - res.val, self.val, other_c.val, n, res.ctx.mod.val - ) - return res - - def mul_low(self, other, slong n): - r""" - Returns the lowest ``n`` coefficients of the multiplication of ``self`` with ``other`` - - Equivalent to computing `f(x) \cdot g(x) \mod x^n` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([2,3,5,7,11]) - >>> g = R([1,2,4,8,16]) - >>> f.mul_low(g, 5) - 101*x^4 + 45*x^3 + 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 3) - 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 1) - 2 - """ - # Only allow multiplication with other fmpz_mod_poly - if not typecheck(other, fmpz_mod_poly): - raise TypeError("other polynomial must be of type fmpz_mod_poly") - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - raise ValueError("other polynomial's context does not match") - - cdef fmpz_mod_poly res - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_mullow( - res.val, self.val, other_c.val, n, res.ctx.mod.val - ) - return res - - def pow_trunc(self, e, slong n): - r""" - Returns ``self`` raised to the power ``e`` modulo `x^n`: - :math:`f^e \mod x^n`/ - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> f.pow_trunc(2**20, 30) == pow(f, 2**20, x**30) - True - >>> f.pow_trunc(2**20, 5) - 132*x^4 + 113*x^3 + 36*x^2 + 48*x + 6 - >>> f.pow_trunc(5**25, 5) - 147*x^4 + 98*x^3 + 95*x^2 + 33*x + 126 - """ - if e < 0: - raise ValueError("Exponent must be non-negative") - - cdef fmpz_mod_poly res, tmp - cdef slong e_c - - try: - e_c = e - except OverflowError: - # Exponent does not fit slong - res = self.ctx.new_ctype_poly() - tmp = self.ctx.new_ctype_poly() - ebytes = e.to_bytes((e.bit_length() + 15) // 16 * 2, "big") - fmpz_mod_poly_pow_trunc(res.val, self.val, ebytes[0] * 256 + ebytes[1], n, res.ctx.mod.val) - for i in range(2, len(ebytes), 2): - fmpz_mod_poly_pow_trunc(res.val, res.val, 1 << 16, n, res.ctx.mod.val) - fmpz_mod_poly_pow_trunc(tmp.val, self.val, ebytes[i] * 256 + ebytes[i+1], n, res.ctx.mod.val) - fmpz_mod_poly_mullow(res.val, res.val, tmp.val, n, res.ctx.mod.val) - return res - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_pow_trunc(res.val, self.val, e_c, n, res.ctx.mod.val) - return res - - def inflate(self, ulong n): - r""" - Returns the result of the polynomial `f = \textrm{self}` to - `f(x^n)` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.inflate(10) - 3*x^20 + 2*x^10 + 1 - - """ - cdef fmpz_mod_poly res - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_inflate( - res.val, self.val, n, res.ctx.mod.val - ) - return res - - def deflate(self, ulong n): - r""" - Returns the result of the polynomial `f = \textrm{self}` to - `f(x^{1/n})` - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,0,2,0,3]) - >>> f - 3*x^4 + 2*x^2 + 1 - >>> f.deflate(2) - 3*x^2 + 2*x + 1 - - """ - cdef fmpz_mod_poly res - - n_max = fmpz_mod_poly_deflation( - self.val, self.ctx.mod.val - ) - if n > n_max: - raise ValueError(f"Cannot deflate with n = {n}, maximum allowed value is n_max = {n_max}") - - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_deflate( - res.val, self.val, n, res.ctx.mod.val - ) - return res - - def deflation(self): - r""" - Returns the tuple (g, n) where for `f = \textrm{self}` to - `g = f(x^{1/n})` where n is the largest allowed integer - - >>> R = fmpz_mod_poly_ctx(163) - >>> f = R([1,0,2,0,3]) - >>> f - 3*x^4 + 2*x^2 + 1 - >>> f.deflate(2) - 3*x^2 + 2*x + 1 - - """ - cdef fmpz_mod_poly res - if self.is_zero(): - return self, 1 - n = fmpz_mod_poly_deflation( - self.val, self.ctx.mod.val - ) - res = self.ctx.new_ctype_poly() - fmpz_mod_poly_deflate( - res.val, self.val, n, res.ctx.mod.val - ) - return res, int(n) - - def factor_squarefree(self): - """ - Factors self into irreducible, squarefree factors, returning a tuple - ``(c, factors)`` where `c` is the content of the coefficients and - factors is a list of ``(poly, exp)`` pairs. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = (x + 1) * (x + 2) - >>> f.factor_squarefree() - (fmpz_mod(1, 163), [(x^2 + 3*x + 2, 1)]) - >>> f = (x + 1) * (x + 2)**5 - >>> f.factor_squarefree() - (fmpz_mod(1, 163), [(x + 1, 1), (x + 2, 5)]) - """ - cdef fmpz_mod_poly_factor_t fac - cdef int i - - if not self.ctx.is_prime(): - raise DomainError("factor_squarefree algorithm assumes that the modulus is prime") - - fmpz_mod_poly_factor_init(fac, self.ctx.mod.val) - fmpz_mod_poly_factor_squarefree(fac, self.val, self.ctx.mod.val) - - res = [0] * fac.num - - cdef fmpz_mod_poly u - for i in range(fac.num): - u = self.ctx.new_ctype_poly() - fmpz_mod_poly_set(u.val, &fac.poly[i], self.ctx.mod.val) - exp = fac.exp[i] - res[i] = (u, exp) - return self.leading_coefficient(), res - - def factor(self, algorithm=None): - """ - Factors self into irreducible factors, returning a tuple - ``(c, factors)`` where `c` is the content of the coefficients and - factors is a list of ``(poly, exp)`` pairs. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = 6*x**4 + 7*x**3 + 7*x**2 + 8*x + 6 - >>> f.factor() - (fmpz_mod(6, 163), [(x^4 + 137*x^3 + 137*x^2 + 110*x + 1, 1)]) - >>> f = (x + 1)**3 * (x + 2) - >>> f.factor() - (fmpz_mod(1, 163), [(x + 1, 3), (x + 2, 1)]) - """ - cdef fmpz_mod_poly_factor_t fac - cdef int i - - if not self.ctx.is_prime(): - raise DomainError("factor algorithm assumes that the modulus is prime") - - # XXX: fmpz_mod_poly_factor with modulus 163 crashes on the zero poly: - # - # Exception (fmpz_mod_poly_powmod_fmpz_binexp). Divide by zero - # - # We handle this special case first: - cdef fmpz_mod constant - if self.is_constant(): - if self.is_zero(): - constant = fmpz_mod.__new__(fmpz_mod) - constant.ctx = self.ctx.mod - else: - constant = self[0] - return (constant, []) - - fmpz_mod_poly_factor_init(fac, self.ctx.mod.val) - if algorithm is None: - fmpz_mod_poly_factor(fac, self.val, self.ctx.mod.val) - elif algorithm == "cantor_zassenhaus": - fmpz_mod_poly_factor_cantor_zassenhaus(fac, self.val, self.ctx.mod.val) - elif algorithm == "kaltofen_shoup": - fmpz_mod_poly_factor_kaltofen_shoup(fac, self.val, self.ctx.mod.val) - elif algorithm == "berlekamp": - fmpz_mod_poly_factor_berlekamp(fac, self.val, self.ctx.mod.val) - else: - raise ValueError("unknown algorithm") - - res = [0] * fac.num - - cdef fmpz_mod_poly u - for i in range(fac.num): - u = self.ctx.new_ctype_poly() - fmpz_mod_poly_set(u.val, &fac.poly[i], self.ctx.mod.val) - exp = fac.exp[i] - res[i] = (u, exp) - return self.leading_coefficient(), res - - def roots(self, multiplicities=True): - r""" - Return the roots of the polynomial in :math:`(\mathbb{Z}/N\mathbb{Z})^*` - Requires that the modulus `N` is prime. - - >>> R = fmpz_mod_poly_ctx(163) - >>> x = R.gen() - >>> f = (x - 1) * (x - 2)**3 * (x - 3)**5 - >>> f.roots() - [(fmpz_mod(1, 163), 1), (fmpz_mod(2, 163), 3), (fmpz_mod(3, 163), 5)] - >>> f.roots(multiplicities=False) - [fmpz_mod(1, 163), fmpz_mod(2, 163), fmpz_mod(3, 163)] - """ - cdef fmpz_mod_poly_factor_t fac - cdef int i, with_multiplicity - - with_multiplicity = 0 - if multiplicities: - with_multiplicity = 1 - - if not self.ctx.is_prime(): - raise NotImplementedError("factor algorithm assumes that the modulus is prime") - - fmpz_mod_poly_factor_init(fac, self.ctx.mod.val) - fmpz_mod_poly_roots(fac, self.val, with_multiplicity, self.ctx.mod.val) - res = [0] * fac.num - - cdef fmpz_mod root - for i in range(fac.num): - root = fmpz_mod.__new__(fmpz_mod) - root.ctx = self.ctx.mod - fmpz_mod_poly_get_coeff_fmpz( - root.val, &fac.poly[i], 0, self.ctx.mod.val - ) - fmpz_mod_neg( - root.val, root.val, root.ctx.val - ) - if multiplicities: - mul = fac.exp[i] - res[i] = (root, mul) - else: - res[i] = root - return res - - def real_roots(self): - r""" - This method is not implemented for polynomials in - :math:`(\mathbb{Z}/N\mathbb{Z})[X]` - """ - raise DomainError("Cannot compute real roots for polynomials over integers modulo N") - - def complex_roots(self): - r""" - This method is not implemented for polynomials in - :math:`(\mathbb{Z}/N\mathbb{Z})[X]` - """ - raise DomainError("Cannot compute complex roots for polynomials over integers modulo N") diff --git a/src/flint/types/fmpz_mpoly.pxd b/src/flint/types/fmpz_mpoly.pxd deleted file mode 100644 index 8c4c58ad..00000000 --- a/src/flint/types/fmpz_mpoly.pxd +++ /dev/null @@ -1,36 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mpoly, flint_mpoly_context - -from flint.flintlib.types.fmpz cimport ( - fmpz_mpoly_ctx_t, - fmpz_mpoly_vec_t, - fmpz_mpoly_t, - fmpz_mpoly_struct, -) -from flint.flintlib.functions.fmpz_mpoly cimport fmpz_mpoly_init - - -cdef inline init_fmpz_mpoly(fmpz_mpoly var, fmpz_mpoly_ctx ctx): - var.ctx = ctx - fmpz_mpoly_init(var.val, ctx.val) - var._init = True - -cdef inline fmpz_mpoly create_fmpz_mpoly(fmpz_mpoly_ctx ctx): - cdef fmpz_mpoly var - var = fmpz_mpoly.__new__(fmpz_mpoly) - var.ctx = ctx - fmpz_mpoly_init(var.val, ctx.val) - var._init = True - return var - -cdef class fmpz_mpoly_ctx(flint_mpoly_context): - cdef fmpz_mpoly_ctx_t val - -cdef class fmpz_mpoly(flint_mpoly): - cdef fmpz_mpoly_t val - cdef fmpz_mpoly_ctx ctx - cdef bint _init - -cdef class fmpz_mpoly_vec: - cdef fmpz_mpoly_vec_t val - cdef fmpz_mpoly_ctx ctx - cdef fmpz_mpoly_struct **double_indirect diff --git a/src/flint/types/fmpz_mpoly.pyi b/src/flint/types/fmpz_mpoly.pyi deleted file mode 100644 index 862aa9fa..00000000 --- a/src/flint/types/fmpz_mpoly.pyi +++ /dev/null @@ -1,137 +0,0 @@ -from typing import Iterable, Iterator, Mapping, Any - -from ..flint_base.flint_base import flint_mpoly, flint_mpoly_context, Ordering -from .fmpz import fmpz - - -_str = str -ifmpz = int | fmpz - - -class fmpz_mpoly_ctx(flint_mpoly_context[fmpz_mpoly, fmpz, ifmpz]): - @classmethod - def get(cls, - names: _str | Iterable[_str | tuple[_str, int]] | tuple[_str, int], - ordering: Ordering | _str = Ordering.lex - ) -> fmpz_mpoly_ctx: - ... - - def nvars(self) -> int: ... - def ordering(self) -> Ordering: ... - def gen(self, i: int, /) -> fmpz_mpoly: ... - def from_dict(self, d: Mapping[tuple[int, ...], ifmpz], /) -> fmpz_mpoly: ... - def constant(self, z: ifmpz, /) -> fmpz_mpoly: ... - def name(self, i: int, /) -> str: ... - def names(self) -> tuple[str, ...]: ... - def gens(self) -> tuple[fmpz_mpoly, ...]: ... - def variable_to_index(self, var: str, /) -> int: ... - def term( - self, coeff: ifmpz | None = None, exp_vec: Iterable[int] | None = None - ) -> fmpz_mpoly: ... - def drop_gens(self, gens: Iterable[str | int], /) -> fmpz_mpoly_ctx: ... - def append_gens(self, gens: Iterable[str | int], /) -> fmpz_mpoly_ctx: ... - def infer_generator_mapping( - self, ctx: flint_mpoly_context, / - ) -> dict[int, int]: ... - @classmethod - def from_context( - cls, - ctx: flint_mpoly_context[Any, Any, Any], - names: str | Iterable[str | tuple[str, int]] | tuple[str, int] | None = None, - ordering: Ordering | str = Ordering.lex, - ) -> fmpz_mpoly_ctx: ... - -class fmpz_mpoly(flint_mpoly[fmpz_mpoly_ctx, fmpz, ifmpz]): - - def __init__(self, - val: fmpz_mpoly | ifmpz | Mapping[tuple[int, ...], ifmpz] | _str = 0, - ctx: fmpz_mpoly_ctx | None = None - ) -> None: ... - - def str(self) -> _str: ... - def repr(self) -> _str: ... - - def context(self) -> fmpz_mpoly_ctx: ... - - def degrees(self) -> tuple[int, ...]: ... - def total_degree(self) -> int: ... - - def is_one(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_constant(self) -> bool: ... - - def __len__(self) -> int: ... - def coefficient(self, i: int) -> fmpz: ... - def monomial(self, i: int) -> tuple[int, ...]: ... - - def monoms(self) -> list[tuple[int, ...]]: ... - def coeffs(self) -> list[fmpz]: ... - def __getitem__(self, index: tuple[int, ...]) -> fmpz: ... - def __setitem__(self, index: tuple[int, ...], coeff: ifmpz) -> None: ... - - def subs(self, mapping: Mapping[_str | int, ifmpz]) -> fmpz_mpoly: ... - def compose(self, *args: fmpz_mpoly, ctx: fmpz_mpoly_ctx | None = None) -> fmpz_mpoly: ... - - def __call__(self, *args: ifmpz) -> fmpz: ... - - def __pos__(self) -> fmpz_mpoly: ... - def __neg__(self) -> fmpz_mpoly: ... - def __add__(self, other: fmpz_mpoly | ifmpz) -> fmpz_mpoly: ... - def __radd__(self, other: ifmpz) -> fmpz_mpoly: ... - def __sub__(self, other: fmpz_mpoly | ifmpz) -> fmpz_mpoly: ... - def __rsub__(self, other: ifmpz) -> fmpz_mpoly: ... - def __mul__(self, other: fmpz_mpoly | ifmpz) -> fmpz_mpoly: ... - def __rmul__(self, other: ifmpz) -> fmpz_mpoly: ... - def __truediv__(self, other: fmpz_mpoly | ifmpz) -> fmpz_mpoly: ... - def __rtruediv__(self, other: ifmpz) -> fmpz_mpoly: ... - def __floordiv__(self, other: fmpz_mpoly | ifmpz) -> fmpz_mpoly: ... - def __rfloordiv__(self, other: ifmpz) -> fmpz_mpoly: ... - def __mod__(self, other: fmpz_mpoly | ifmpz) -> fmpz_mpoly: ... - def __rmod__(self, other: ifmpz) -> fmpz_mpoly: ... - def __divmod__(self, other: fmpz_mpoly | ifmpz) -> tuple[fmpz_mpoly, fmpz_mpoly]: ... - def __rdivmod__(self, other: ifmpz) -> tuple[fmpz_mpoly, fmpz_mpoly]: ... - def __pow__(self, other: ifmpz) -> fmpz_mpoly: ... - def __rpow__(self, other: ifmpz) -> fmpz_mpoly: ... - - def iadd(self, other: fmpz_mpoly | ifmpz) -> None: ... - def isub(self, other: fmpz_mpoly | ifmpz) -> None: ... - def imul(self, other: fmpz_mpoly | ifmpz) -> None: ... - - def gcd(self, other: fmpz_mpoly) -> fmpz_mpoly: ... - def term_content(self) -> fmpz_mpoly: ... - def primitive(self) -> tuple[fmpz, fmpz_mpoly]: ... - - def factor(self) -> tuple[fmpz, list[tuple[fmpz_mpoly, int]]]: ... - def factor_squarefree(self) -> tuple[fmpz, list[tuple[fmpz_mpoly, int]]]: ... - - def sqrt(self, assume_perfect_square: bool = False) -> fmpz_mpoly: ... - - def resultant(self, other: fmpz_mpoly, var: _str | int) -> fmpz_mpoly: ... - def discriminant(self, var: _str | int) -> fmpz_mpoly: ... - - def deflation(self) -> tuple[fmpz_mpoly, list[int]]: ... - def inflate(self, N: list[int]) -> fmpz_mpoly: ... - def deflate(self, N: list[int]) -> fmpz_mpoly: ... - def deflation_monom(self) -> tuple[fmpz_mpoly, list[int], fmpz_mpoly]: ... - def deflation_index(self) -> tuple[list[int], list[int]]: ... - - def derivative(self, var: _str | int) -> fmpz_mpoly: ... - def integral(self, var: _str | int) -> tuple[int, fmpz_mpoly]: ... - - -class fmpz_mpoly_vec: - def __init__(self, - iterable_or_len: int | Iterable[fmpz_mpoly], - ctx: fmpz_mpoly_ctx, - double_indirect: bool = False - ) -> None: ... - - def __iter__(self) -> Iterator[fmpz_mpoly]: ... - def __getitem__(self, index: int) -> fmpz_mpoly: ... - def __setitem__(self, index: int, value: fmpz_mpoly) -> None: ... - - def buchberger_naive(self, limits: tuple[int, int, int] | None = None) -> fmpz_mpoly_vec: ... - def autoreduction(self) -> fmpz_mpoly_vec: ... - - def is_groebner(self, other: fmpz_mpoly_vec | None = None) -> bool: ... - def is_autoreduced(self) -> bool: ... diff --git a/src/flint/types/fmpz_mpoly.pyx b/src/flint/types/fmpz_mpoly.pyx deleted file mode 100644 index a4f11308..00000000 --- a/src/flint/types/fmpz_mpoly.pyx +++ /dev/null @@ -1,1467 +0,0 @@ -cimport cython - -from flint.flintlib.types.flint cimport ulong - -from flint.flint_base.flint_base cimport ( - flint_mpoly, - flint_mpoly_context, - ordering_py_to_c, - ordering_c_to_py, -) - -from flint.utils.typecheck cimport typecheck -from flint.utils.flint_exceptions import DomainError, IncompatibleContextError - -from flint.types.fmpz cimport any_as_fmpz, fmpz -from flint.types.fmpz_vec cimport fmpz_vec - -from flint.flintlib.types.flint cimport slong -from flint.flintlib.types.fmpz cimport fmpz_mpoly_vec_entry -from flint.flintlib.functions.fmpz cimport fmpz_set - -from flint.flintlib.functions.fmpz_mpoly cimport ( - fmpz_mpoly_add, - fmpz_mpoly_add_fmpz, - fmpz_mpoly_buchberger_naive, - fmpz_mpoly_buchberger_naive_with_limits, - fmpz_mpoly_clear, - fmpz_mpoly_compose_fmpz_mpoly, - fmpz_mpoly_compose_fmpz_mpoly_gen, - fmpz_mpoly_ctx_init, - fmpz_mpoly_deflate, - fmpz_mpoly_deflation, - fmpz_mpoly_degrees_fmpz, - fmpz_mpoly_derivative, - fmpz_mpoly_discriminant, - fmpz_mpoly_div, - fmpz_mpoly_divides, - fmpz_mpoly_divrem, - fmpz_mpoly_equal, - fmpz_mpoly_equal_fmpz, - fmpz_mpoly_evaluate_all_fmpz, - fmpz_mpoly_evaluate_one_fmpz, - fmpz_mpoly_gcd, - fmpz_mpoly_gen, - fmpz_mpoly_get_coeff_fmpz_fmpz, - fmpz_mpoly_get_str_pretty, - fmpz_mpoly_get_term_coeff_fmpz, - fmpz_mpoly_get_term_exp_fmpz, - fmpz_mpoly_inflate, - fmpz_mpoly_integral, - fmpz_mpoly_is_one, - fmpz_mpoly_is_zero, - fmpz_mpoly_length, - fmpz_mpoly_mul, - fmpz_mpoly_neg, - fmpz_mpoly_pow_fmpz, - fmpz_mpoly_push_term_fmpz_ffmpz, - fmpz_mpoly_push_term_ui_ffmpz, - fmpz_mpoly_reduction_primitive_part, - fmpz_mpoly_resultant, - fmpz_mpoly_scalar_divexact_fmpz, - fmpz_mpoly_scalar_divides_fmpz, - fmpz_mpoly_scalar_mul_fmpz, - fmpz_mpoly_set, - fmpz_mpoly_set_coeff_fmpz_fmpz, - fmpz_mpoly_set_fmpz, - fmpz_mpoly_set_str_pretty, - fmpz_mpoly_sort_terms, - fmpz_mpoly_spoly, - fmpz_mpoly_sqrt_heap, - fmpz_mpoly_sub, - fmpz_mpoly_sub_fmpz, - fmpz_mpoly_term_content, - fmpz_mpoly_total_degree_fmpz, - fmpz_mpoly_vec_autoreduction, - fmpz_mpoly_vec_autoreduction_groebner, - fmpz_mpoly_vec_clear, - fmpz_mpoly_vec_init, - fmpz_mpoly_vec_is_autoreduced, - fmpz_mpoly_vec_is_groebner, -) -from flint.flintlib.functions.fmpz_mpoly_factor cimport ( - fmpz_mpoly_factor, - fmpz_mpoly_factor_clear, - fmpz_mpoly_factor_init, - fmpz_mpoly_factor_squarefree, - fmpz_mpoly_factor_t, -) -from flint.flintlib.functions.fmpz_vec cimport _fmpz_vec_content - -from cpython.object cimport Py_EQ, Py_NE -cimport libc.stdlib - -cdef dict _fmpz_mpoly_ctx_cache = {} - - -cdef class fmpz_mpoly_ctx(flint_mpoly_context): - """ - A class for storing the polynomial context - - :param names: A tuple containing the names of the variables of the ring. - :param ordering: The term order for the ring. - - Do not construct one of these directly, use ``fmpz_mpoly_ctx.get``. - """ - - _ctx_cache = _fmpz_mpoly_ctx_cache - - @classmethod - def _new_(cls, names, ordering): - cdef fmpz_mpoly_ctx self = cls.__new__(cls) - super()._new_(self, names) - fmpz_mpoly_ctx_init(self.val, len(names), ordering_py_to_c(ordering)) - return self - - def _any_as_scalar(self, other): - if isinstance(other, int): - return any_as_fmpz(other) - elif typecheck(other, fmpz): - res = fmpz.__new__(fmpz) - fmpz_set((res).val, (other).val) - return res - else: - return NotImplemented - - def _scalar_as_mpoly(self, other: fmpz): - # non-fmpz scalars should first be converted via self._any_as_scalar - return self.constant(other) - - def nvars(self): - """ - Return the number of variables in the context - - >>> ctx = fmpz_mpoly_ctx.get(('x', 4), 'lex') - >>> ctx.nvars() - 4 - """ - return self.val.minfo.nvars - - def ordering(self): - """ - Return the term order of the context object. - - >>> ctx = fmpz_mpoly_ctx.get(('w', 4), 'deglex') - >>> ctx.ordering() - - """ - return ordering_c_to_py(self.val.minfo.ord) - - def gen(self, slong i): - """ - Return the ``i`` th generator of the polynomial ring - - >>> ctx = fmpz_mpoly_ctx.get(('z', 3), 'degrevlex') - >>> ctx.gen(1) - z1 - """ - cdef fmpz_mpoly res - if not 0 <= i < self.val.minfo.nvars: - raise IndexError("generator index out of range") - res = create_fmpz_mpoly(self) - fmpz_mpoly_gen(res.val, i, res.ctx.val) - return res - - def constant(self, z): - """ - Create a constant polynomial in this context - """ - cdef fmpz_mpoly res - z = any_as_fmpz(z) - if z is NotImplemented: - raise TypeError("cannot coerce argument to fmpz") - res = create_fmpz_mpoly(self) - fmpz_mpoly_set_fmpz(res.val, (z).val, res.ctx.val) - return res - - def from_dict(self, d): - """ - Create a fmpz_mpoly from a dictionary in this context. - - The dictionary's keys are tuples of ints (or anything that implicitly converts - to fmpz) representing exponents, and corresponding values of fmpz. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> ctx.from_dict({(1,0):2, (1,1):3, (0,1):1}) - 3*x*y + 2*x + y - """ - cdef: - fmpz_vec exp_vec - slong i, nvars = self.nvars() - fmpz_mpoly res - - if not isinstance(d, dict): - raise ValueError("expected a dictionary") - - res = create_fmpz_mpoly(self) - - for i, (k, v) in enumerate(d.items()): - o = any_as_fmpz(v) - if o is NotImplemented: - raise TypeError(f"cannot coerce coefficient '{v}' to fmpz") - elif len(k) != nvars: - raise ValueError(f"expected {nvars} exponents, got {len(k)}") - - exp_vec = fmpz_vec(k) - - if o: - fmpz_mpoly_push_term_fmpz_ffmpz(res.val, (o).val, exp_vec.val, self.val) - - fmpz_mpoly_sort_terms(res.val, self.val) - return res - - -cdef class fmpz_mpoly(flint_mpoly): - """ - The *fmpz_mpoly* type represents sparse multivariate polynomials over - the integers. - """ - - def __cinit__(self): - self._init = False - - def __dealloc__(self): - if self._init: - fmpz_mpoly_clear(self.val, self.ctx.val) - self._init = False - - def __init__(self, val=0, ctx=None): - if typecheck(val, fmpz_mpoly): - if ctx is None or ctx == (val).ctx: - init_fmpz_mpoly(self, (val).ctx) - fmpz_mpoly_set(self.val, (val).val, self.ctx.val) - else: - raise IncompatibleContextError(f"{ctx} is not {(val).ctx}") - elif isinstance(val, dict): - if ctx is None: - raise ValueError("a context is required to create a fmpz_mpoly from a dict") - x = ctx.from_dict(val) - # XXX: this copy is silly, have a ctx function that assigns an fmpz_mpoly_t - init_fmpz_mpoly(self, ctx) - fmpz_mpoly_set(self.val, (x).val, self.ctx.val) - elif isinstance(val, str): - if ctx is None: - raise ValueError("cannot parse a polynomial without context") - val = bytes(val, 'utf-8') - init_fmpz_mpoly(self, ctx) - if fmpz_mpoly_set_str_pretty(self.val, val, self.ctx.c_names, self.ctx.val) == -1: - raise ValueError("unable to parse fmpz_mpoly from string") - fmpz_mpoly_sort_terms(self.val, self.ctx.val) - else: - v = any_as_fmpz(val) - if v is NotImplemented: - raise TypeError("cannot create fmpz_mpoly from type %s" % type(val)) - if ctx is None: - raise ValueError("need context to convert fmpz to fmpz_mpoly") - init_fmpz_mpoly(self, ctx) - fmpz_mpoly_set_fmpz(self.val, (v).val, self.ctx.val) - - def __bool__(self): - return not fmpz_mpoly_is_zero(self.val, self.ctx.val) - - def is_zero(self): - return fmpz_mpoly_is_zero(self.val, self.ctx.val) - - def is_one(self): - return fmpz_mpoly_is_one(self.val, self.ctx.val) - - def is_constant(self): - """ - Returns True if this is a constant polynomial. - - >>> ctx = fmpz_mpoly_ctx.get(['x', 'y']) - >>> x, y = ctx.gens() - >>> p = x**2 + y - >>> p.is_constant() - False - >>> (0*p + 1).is_constant() - True - """ - return self.total_degree() <= 0 - - def __richcmp__(self, other, int op): - if not (op == Py_EQ or op == Py_NE): - return NotImplemented - elif other is None: - return op == Py_NE - elif typecheck(other, fmpz_mpoly): - if (self).ctx is (other).ctx: - return (op == Py_NE) ^ fmpz_mpoly_equal(self.val, (other).val, self.ctx.val) - else: - return op == Py_NE - elif typecheck(other, fmpz): - return (op == Py_NE) ^ fmpz_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - elif isinstance(other, int): - other = any_as_fmpz(other) - if other is NotImplemented: - return NotImplemented - return (op == Py_NE) ^ fmpz_mpoly_equal_fmpz(self.val, (other).val, self.ctx.val) - else: - return NotImplemented - - def __len__(self): - return fmpz_mpoly_length(self.val, self.ctx.val) - - def __getitem__(self, x): - """ - Return the coefficient of the term with the exponent vector ``x``. - Always returns a value, missing keys will return ``0``. - Negative exponents are made positive. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] - 3 - - """ - cdef: - slong nvars = self.ctx.nvars() - - if not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - res = fmpz() - exp_vec = fmpz_vec(x, double_indirect=True) - fmpz_mpoly_get_coeff_fmpz_fmpz((res).val, self.val, exp_vec.double_indirect, self.ctx.val) - return res - - def __setitem__(self, x, y): - """ - Set the coefficient of the term with the exponent vector ``x`` to ``y``. - Will always set a value, missing keys will create a new term. - Negative exponents are made positive. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] = 20 - >>> p - 20*x0*x1 + 2*x1 - - """ - cdef: - slong nvars = self.ctx.nvars() - - coeff = any_as_fmpz(y) - if coeff is NotImplemented: - raise TypeError("provided coefficient not coercible to fmpz") - elif not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - exp_vec = fmpz_vec(x, double_indirect=True) - fmpz_mpoly_set_coeff_fmpz_fmpz(self.val, (coeff).val, exp_vec.double_indirect, self.ctx.val) - - def __neg__(self): - cdef fmpz_mpoly res - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_neg(res.val, (self).val, res.ctx.val) - return res - - cdef _add_scalar_(self, arg): - cdef fmpz_mpoly res - cdef fmpz other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_add_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _sub_scalar_(self, arg): - cdef fmpz_mpoly res - cdef fmpz other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_sub_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _mul_scalar_(self, arg): - cdef fmpz_mpoly res - cdef fmpz other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_scalar_mul_fmpz(res.val, self.val, other.val, self.ctx.val) - return res - - cdef _pow_(self, arg): - cdef fmpz_mpoly res - cdef fmpz other = arg - res = create_fmpz_mpoly(self.ctx) - if fmpz_mpoly_pow_fmpz(res.val, self.val, other.val, res.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - cdef _add_mpoly_(self, arg): - cdef fmpz_mpoly res, other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_add(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _sub_mpoly_(self, arg): - cdef fmpz_mpoly res, other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_sub(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _mul_mpoly_(self, arg): - cdef fmpz_mpoly res, other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_mul(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _divmod_mpoly_(self, arg): - cdef fmpz_mpoly quotient, remainder, other = arg - quotient = create_fmpz_mpoly(self.ctx) - remainder = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return (quotient, remainder) - - cdef _floordiv_mpoly_(self, arg): - cdef fmpz_mpoly quotient, other = arg - quotient = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_div(quotient.val, self.val, other.val, self.ctx.val) - return quotient - - cdef _truediv_scalar_(self, arg): - cdef fmpz_mpoly quotient, - cdef fmpz other = arg - quotient = create_fmpz_mpoly(self.ctx) - if fmpz_mpoly_scalar_divides_fmpz(quotient.val, self.val, other.val, self.ctx.val): - return quotient - else: - raise DomainError("fmpz_mpoly division is not exact") - - cdef _divexact_scalar_(self, arg): - cdef fmpz_mpoly quotient, - cdef fmpz other = arg - quotient = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_scalar_divexact_fmpz(quotient.val, self.val, other.val, self.ctx.val) - return quotient - - cdef _truediv_mpoly_(self, arg): - cdef fmpz_mpoly quotient, other = arg - quotient = create_fmpz_mpoly(self.ctx) - if fmpz_mpoly_divides(quotient.val, self.val, other.val, self.ctx.val): - return quotient - else: - raise DomainError("fmpz_mpoly division is not exact") - - cdef _mod_mpoly_(self, arg): - cdef fmpz_mpoly quotient, remainder, other = arg - quotient = create_fmpz_mpoly(self.ctx) - remainder = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return remainder - - cdef _rsub_scalar_(self, arg): - cdef fmpz_mpoly res - cdef fmpz other = arg - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_sub_fmpz(res.val, self.val, other.val, self.ctx.val) - fmpz_mpoly_neg(res.val, res.val, res.ctx.val) - return res - - cdef _rsub_mpoly_(self, arg): - return (arg)._sub_mpoly_(self) - - cdef _rdivmod_mpoly_(self, arg): - return (arg)._divmod_mpoly_(self) - - cdef _rfloordiv_mpoly_(self, arg): - return (arg)._floordiv_mpoly_(self) - - cdef _rtruediv_mpoly_(self, arg): - return (arg)._truediv_mpoly_(self) - - cdef _rmod_mpoly_(self, arg): - return (arg)._mod_mpoly_(self) - - cdef _iadd_scalar_(self, arg): - cdef fmpz other = arg - fmpz_mpoly_add_fmpz(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_scalar_(self, arg): - cdef fmpz other = arg - fmpz_mpoly_sub_fmpz(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_scalar_(self, arg): - cdef fmpz other = arg - fmpz_mpoly_scalar_mul_fmpz(self.val, self.val, other.val, self.ctx.val) - - cdef _iadd_mpoly_(self, arg): - cdef fmpz_mpoly other = arg - fmpz_mpoly_add(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_mpoly_(self, arg): - cdef fmpz_mpoly other = arg - fmpz_mpoly_sub(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_mpoly_(self, arg): - cdef fmpz_mpoly other = arg - fmpz_mpoly_mul(self.val, self.val, other.val, self.ctx.val) - - def __call__(self, *args) -> fmpz: - cdef: - fmpz_vec V - fmpz vres - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs != nvars: - raise ValueError("number of generators does not match number of arguments") - - V = fmpz_vec(args, double_indirect=True) - vres = fmpz.__new__(fmpz) - if fmpz_mpoly_evaluate_all_fmpz(vres.val, self.val, V.double_indirect, self.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return vres - - def monoms(self): - """ - Return the exponent vectors of each term as a tuple of fmpz. - - >>> 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.monoms() - [(1, 1), (1, 0), (0, 1), (0, 0)] - - """ - cdef: - slong i, nvars = self.ctx.nvars() - fmpz_vec vec = fmpz_vec(nvars, double_indirect=True) - - res = [] - for i in range(len(self)): - fmpz_mpoly_get_term_exp_fmpz(vec.double_indirect, self.val, i, self.ctx.val) - res.append(tuple(vec)) - - return res - - def coeffs(self): - """ - Return the coefficients of each term as a fmpz - - >>> 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] - - """ - cdef: - fmpz coeff - slong i - - res = [] - for i in range(len(self)): - coeff = fmpz.__new__(fmpz) - fmpz_mpoly_get_term_coeff_fmpz(coeff.val, self.val, i, self.ctx.val) - res.append(coeff) - - return res - - def subs(self, dict_args) -> fmpz_mpoly: - """ - Partial evaluate this polynomial with select constants. Keys must be generator names or generator indices, - all values must be fmpz. - - >>> 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.subs({"x1": 0}) - 2*x0 + 1 - - """ - cdef: - fmpz_mpoly res - slong i - - args = tuple((self.ctx.variable_to_index(k), any_as_fmpz(v)) for k, v in dict_args.items()) - for _, v in args: - if v is NotImplemented: - raise TypeError(f"cannot coerce argument ('{v}') to fmpz") - - # Partial application with args in Z. We evaluate the polynomial one variable at a time - res = create_fmpz_mpoly(self.ctx) - - fmpz_mpoly_set(res.val, self.val, self.ctx.val) - for i, arg in args: - if fmpz_mpoly_evaluate_one_fmpz(res.val, res.val, i, (arg).val, self.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - def compose(self, *args, ctx=None) -> fmpz_mpoly: - """ - Compose this polynomial with other fmpz_mpolys. All arguments must share the same context, it may different - from this polynomials context. - - >>> ctx = fmpz_mpoly_ctx.get(('x',), 'lex') - >>> ctx1 = fmpz_mpoly_ctx.get(('y', 2), '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 - - """ - cdef: - fmpz_mpoly res - fmpz_mpoly_ctx res_ctx - fmpz_mpoly_vec C - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs < nvars: - raise ValueError("not enough arguments provided") - elif nargs > nvars: - raise ValueError("more arguments provided than variables") - elif self.ctx.nvars() == 0 and ctx is None: - raise ValueError("a context must be provided when composing a polynomial with no generators") - elif not all(typecheck(arg, fmpz_mpoly) for arg in args): - raise TypeError("all arguments must be fmpz_mpolys") - - if ctx is None: - res_ctx = ( args[0]).ctx - elif typecheck(ctx, fmpz_mpoly_ctx): - res_ctx = ctx - else: - raise TypeError(f"provided context ({ctx}) is not a fmpz_mpoly_ctx") - - if not all(( arg).ctx is res_ctx for arg in args): - raise IncompatibleContextError( - "all arguments must share the " + ("same" if ctx is not None else "provided") + " context" - ) - - C = fmpz_mpoly_vec(args, res_ctx, double_indirect=True) - res = create_fmpz_mpoly(res_ctx) - if fmpz_mpoly_compose_fmpz_mpoly(res.val, self.val, C.double_indirect, self.ctx.val, res_ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - def context(self): - """ - Return the context object for this polynomials. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2}) - >>> ctx is p.context() - True - """ - return self.ctx - - def coefficient(self, slong i): - """ - Return the coefficient at index ``i``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.coefficient(1) - 2 - """ - cdef fmpz v - if not 0 <= i < fmpz_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - else: - v = fmpz.__new__(fmpz) - fmpz_mpoly_get_term_coeff_fmpz(v.val, self.val, i, self.ctx.val) - return v - - def monomial(self, slong i): - """ - Return the exponent vector at index ``i`` as a tuple. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.monomial(1) - (0, 1) - """ - cdef: - slong nvars = self.ctx.nvars() - - if not 0 <= i < fmpz_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - res = fmpz_vec(nvars, double_indirect=True) - fmpz_mpoly_get_term_exp_fmpz(res.double_indirect, self.val, i, self.ctx.val) - return tuple(res) - - def degrees(self): - """ - Return a tuple of degrees. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 4), 'lex') - >>> p = sum(x**i for i, x in enumerate(ctx.gens())) - >>> p - x1 + x2^2 + x3^3 + 1 - >>> p.degrees() - (0, 1, 2, 3) - """ - cdef: - slong nvars = self.ctx.nvars() - - res = fmpz_vec(nvars, double_indirect=True) - fmpz_mpoly_degrees_fmpz(res.double_indirect, self.val, self.ctx.val) - return tuple(res) - - def total_degree(self): - """ - Return the total degree. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 4), 'lex') - >>> p = ctx.from_dict({(1, 0, 0, 0): 1, (0, 2, 0, 0): 2, (0, 0, 3, 0): 3}) - >>> p.total_degree() - 3 - """ - cdef fmpz res = fmpz() - fmpz_mpoly_total_degree_fmpz(( res).val, self.val, self.ctx.val) - return res - - def leading_coefficient(self): - """ - Leading coefficient in the monomial ordering. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), '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 - - """ - if fmpz_mpoly_is_zero(self.val, self.ctx.val): - return fmpz(0) - else: - return self.coefficient(0) - - def repr(self): - return f"{self.ctx}.from_dict({self.to_dict()})" - - def str(self): - cdef bytes s = fmpz_mpoly_get_str_pretty(self.val, self.ctx.c_names, self.ctx.val) - res = s.decode().replace("+", " + ").replace("-", " - ") - if res.startswith(" - "): - res = "-" + res[3:] - return res - - def gcd(self, other): - """ - Return the gcd of self and other. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> g = ctx.from_dict({(0, 1): 2, (1, 0): 2}) - >>> (f * g).gcd(f) - 4*x0*x1 + 1 - """ - cdef fmpz_mpoly res - if not typecheck(other, fmpz_mpoly): - raise TypeError("argument must be a fmpz_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_gcd(res.val, (self).val, (other).val, res.ctx.val) - return res - - def content(self): - """ - Return the GCD of the coefficients of ``self``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = 3 * x0**2 * x1 + 6 * x0 * x1 - >>> f.content() - 3 - """ - cdef fmpz res = fmpz() - _fmpz_vec_content(res.val, self.val.coeffs, self.val.length) - return res - - def term_content(self): - """ - Return the GCD of the terms of ``self``. If ``self`` is zero, then the result will - be zero, otherwise it will be a monomial with positive coefficient. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = 3 * x0**2 * x1 + 6 * x0 * x1 - >>> f.term_content() - 3*x0*x1 - """ - cdef fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_term_content(res.val, self.val, self.ctx.val) - return res - - def resultant(self, other, var): - """ - Return the resultant of ``self`` and ``other`` with respect to variable ``var``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = x0**2 * x1 + x0 * x1 - >>> g = x0 + x1 - >>> f.resultant(g, 'x1') - x0^3 + x0^2 - """ - cdef: - fmpz_mpoly res - slong i - - if not typecheck(other, fmpz_mpoly): - raise TypeError("argument must be a fmpz_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - - i = self.ctx.variable_to_index(var) - res = create_fmpz_mpoly(self.ctx) - if not fmpz_mpoly_resultant(res.val, self.val, (other).val, i, self.ctx.val): - raise RuntimeError(f"failed to compute resultant with respect to {var}") - return res - - def discriminant(self, var): - """ - Return the discriminant of ``self`` with respect to variable ``var``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> x0, x1 = ctx.gens() - >>> f = (x0 + x1)**2 + 1 - >>> f.discriminant('x1') - -4 - - """ - cdef: - fmpz_mpoly res - slong i - - i = self.ctx.variable_to_index(var) - res = create_fmpz_mpoly(self.ctx) - if not fmpz_mpoly_discriminant(res.val, self.val, i, self.ctx.val): - raise RuntimeError(f"failed to compute discriminant with respect to {var}") - return res - - def primitive(self): - """ - Return the content and primitive of ``self``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> x, y = ctx.gens() - >>> f = 4*x + 2*x*y - >>> f.primitive() - (2, x0*x1 + 2*x0) - """ - cdef fmpz content = self.content() - return content, self._divexact_scalar_(content) - - def sqrt(self, assume_perfect_square: bool = False): - """ - Return the square root of self. - If self is known to be a perfect square provide ``assume_perfect_square=True`` for a more efficient - result. If self is not a square root the result is not guaranteed to be correct. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> (f * f).sqrt() - 4*x0*x1 + 1 - """ - cdef fmpz_mpoly res - res = create_fmpz_mpoly(self.ctx) - - if fmpz_mpoly_sqrt_heap(res.val, self.val, self.ctx.val, not assume_perfect_square): - return res - else: - raise DomainError("polynomial is not a perfect square") - - def factor(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = fmpz_mpoly - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y', 'z'), 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*z + 3*x + 3*z + 3", ctx) - >>> (p1 * p2).factor() - (6, [(z + 1, 1), (x + 1, 1), (x + 2, 1)]) - >>> (p2 * p1 * p2).factor() - (18, [(x + 2, 1), (z + 1, 2), (x + 1, 2)]) - """ - cdef: - fmpz_mpoly_factor_t fac - fmpz c - fmpz_mpoly u - - fmpz_mpoly_factor_init(fac, self.ctx.val) - if not fmpz_mpoly_factor(fac, self.val, self.ctx.val): - raise RuntimeError("factorisation failed") - res = [0] * fac.num - - for i in range(fac.num): - u = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, fac.constant) - fmpz_mpoly_factor_clear(fac, self.ctx.val) - - res.sort(key=_fmpz_mpoly_sort_key) - - return c, res - - def factor_squarefree(self): - """ - Factors self into square-free factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = fmpz_mpoly - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y', 'z'), 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*y + 3*x + 3*y + 3", ctx) - >>> (p1 * p2).factor_squarefree() - (6, [(y + 1, 1), (x^2 + 3*x + 2, 1)]) - >>> (p1 * p2 * p1).factor_squarefree() - (12, [(y + 1, 1), (x + 1, 1), (x + 2, 2)]) - """ - cdef: - fmpz_mpoly_factor_t fac - fmpz c - fmpz_mpoly u - - fmpz_mpoly_factor_init(fac, self.ctx.val) - fmpz_mpoly_factor_squarefree(fac, self.val, self.ctx.val) - res = [0] * fac.num - - for i in range(fac.num): - u = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_init(u.val, u.ctx.val) - fmpz_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, fac.constant) - fmpz_mpoly_factor_clear(fac, self.ctx.val) - return c, res - - cdef _compose_gens_(self, ctx, slong *mapping): - cdef fmpz_mpoly res = create_fmpz_mpoly(ctx) - fmpz_mpoly_compose_fmpz_mpoly_gen( - res.val, - self.val, - mapping, - self.ctx.val, - (ctx).val - ) - - return res - - def derivative(self, var): - """ - Return the derivative of this polynomial with respect to the provided variable. - The argument can either be the variable as a string, or the index of the - variable in the context. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 3): 2, (2, 1): 3}) - >>> p - 3*x0^2*x1 + 2*x1^3 - >>> p.derivative("x0") - 6*x0*x1 - >>> p.derivative(1) - 3*x0^2 + 6*x1^2 - - """ - cdef: - fmpz_mpoly res - slong i = self.ctx.variable_to_index(var) - - res = create_fmpz_mpoly(self.ctx) - - fmpz_mpoly_derivative(res.val, self.val, i, self.ctx.val) - return res - - def integral(self, var): - """ - Return the integral of this polynomial*B with respect to the provided variable where B is minimal. That is, - given p this method returns (B, P) such that P' = B*p or P/B is the formal integral of p. - - The argument can either be the variable as a string, or the index of the variable in the context. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 2), 'lex') - >>> p = ctx.from_dict({(0, 3): 2, (2, 1): 3}) - >>> p - 3*x0^2*x1 + 2*x1^3 - >>> p.integral("x0") - (1, x0^3*x1 + 2*x0*x1^3) - >>> p.integral(1) - (2, 3*x0^2*x1^2 + x1^4) - - """ - cdef: - fmpz_mpoly res - fmpz scale - slong i = self.ctx.variable_to_index(var) - - res = create_fmpz_mpoly(self.ctx) - - scale = fmpz() - - fmpz_mpoly_integral(res.val, scale.val, self.val, i, self.ctx.val) - return scale, res - - def spoly(self, g): - """ - Compute the S-polynomial of ``self`` and ``g``, scaled to an integer polynomial - by computing the LCM of the leading coefficients. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> f = ctx.from_dict({(2, 0): 1, (0, 1): -1}) - >>> g = ctx.from_dict({(3, 0): 1, (1, 0): -1}) - >>> f.spoly(g) - -x*y + x - """ - cdef fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - - if not typecheck(g, fmpz_mpoly): - raise TypeError(f"expected fmpz_mpoly, got {type(g)}") - - self.ctx.compatible_context_check((g).ctx) - fmpz_mpoly_spoly(res.val, self.val, (g).val, self.ctx.val) - return res - - def reduction_primitive_part(self, vec): - """ - Compute the the primitive part of the reduction (remainder of multivariate - quasi-division with remainder) with respect to the polynomials ``vec``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = 2 * x**3 -x**2 * y + y**3 + 3 * y - >>> g1 = x**2 + y**2 + 1 - >>> g2 = x * y - 2 - >>> vec = fmpz_mpoly_vec([g1, g2], ctx) - >>> vec - fmpz_mpoly_vec([x^2 + y^2 + 1, x*y - 2], ctx=fmpz_mpoly_ctx(2, '', ('x', 'y'))) - >>> f.reduction_primitive_part(vec) - x - y^3 - """ - cdef fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - if not typecheck(vec, fmpz_mpoly_vec): - raise TypeError(f"expected fmpz_mpoly, got {type(vec)}") - - self.ctx.compatible_context_check((vec).ctx) - fmpz_mpoly_reduction_primitive_part(res.val, self.val, (vec).val, self.ctx.val) - return res - - def inflate(self, N: list[int]) -> fmpz_mpoly: - """ - Compute the inflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^N)``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x + y + 1 - >>> f.inflate([2, 3]) - x^2 + y^3 + 1 - """ - - cdef nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - elif any(n < 0 for n in N): - raise ValueError("all inflate strides must be non-negative") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - - fmpz_mpoly_inflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - return res - - def deflate(self, N: list[int]) -> fmpz_mpoly: - """ - Compute the deflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^(1/N))``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> f.deflate([2, 3]) - x + y + 1 - """ - cdef slong nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - - fmpz_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - return res - - def deflation(self) -> tuple[fmpz_mpoly, list[int]]: - """ - Compute the deflation of ``self``, that is ``p(X^(1/N))`` for maximal N. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**2 * y**2 + x * y**2 - >>> q, N = f.deflation() - >>> q, N - (x^2*y + x*y, [1, 2]) - >>> q.inflate(N) == f - True - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - - fmpz_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - - for i in range(nvars): - stride[i] = shift[i].gcd(stride[i]) - shift[i] = 0 - - fmpz_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - - return res, list(stride) - - def deflation_monom(self) -> tuple[fmpz_mpoly, list[int], fmpz_mpoly]: - """ - Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N)) - = m * q(X^N)`` for maximal N. The returned monomial allows the undo-ing of the - deflation. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> fd, N, m = f.deflation_monom() - >>> fd, N, m - (x + y + 1, [2, 3], x*y) - >>> m * fd.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_mpoly res = create_fmpz_mpoly(self.ctx) - fmpz_mpoly monom = create_fmpz_mpoly(self.ctx) - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - fmpz_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - fmpz_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val) - fmpz_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - - return res, list(stride), monom - - def deflation_index(self) -> tuple[list[int], list[int]]: - """ - Compute the exponent vectors ``N`` and ``I`` such that ``p(X^(1/N)) = X^I * - q(X^N)`` for maximal N. Importantly the deflation itself is not computed - here. The returned exponent vector ``I`` is the shift that was applied to the - exponents. It is the exponent vector of the monomial returned by - ``deflation_monom``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> N, I = f.deflation_index() - >>> N, I - ([2, 3], [1, 1]) - >>> f_deflated = f.deflate(N) - >>> f_deflated - x + y + 1 - >>> m = ctx.term(exp_vec=I) - >>> m - x*y - >>> m * f_deflated.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - fmpz_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - return list(stride), list(shift) - - -@cython.final -@cython.no_gc -cdef class _fmpz_mpoly_sort_key: - cdef fmpz_mpoly p - cdef ulong mult - - def __init__(self, tuple fac_m): - self.p = fac_m[0] - self.mult = fac_m[1] - - def __lt__(k1, _fmpz_mpoly_sort_key k2): - cdef slong nterms - cdef tuple monom1, monom2 - cdef int coeff1, coeff2 - if k1.mult != k2.mult: - return k1.mult < k2.mult - nterms = min(k1.p.val.length, k2.p.val.length) - for i in range(nterms): - monom1 = k1.p.monomial(i) - monom2 = k2.p.monomial(i) - if monom1 != monom2: - return monom1 < monom2 - coeff1 = int(k1.p.coefficient(i)) - coeff2 = int(k2.p.coefficient(i)) - if coeff1 != coeff2: - return coeff1 < coeff2 - return k1.p.val.length < k2.p.val.length - - -cdef class fmpz_mpoly_vec: - """ - A class representing a vector of fmpz_mpolys. - """ - - def __cinit__( - self, iterable_or_len, fmpz_mpoly_ctx ctx, bint double_indirect = False - ): - if isinstance(iterable_or_len, int): - length = iterable_or_len - else: - length = len(iterable_or_len) - - self.ctx = ctx - fmpz_mpoly_vec_init(self.val, length, self.ctx.val) - - if double_indirect: - self.double_indirect = libc.stdlib.malloc( - length * sizeof(fmpz_mpoly_struct *) - ) - if self.double_indirect is NULL: - raise MemoryError("malloc returned a null pointer") # pragma: no cover - - for i in range(length): - self.double_indirect[i] = fmpz_mpoly_vec_entry(self.val, i) - else: - self.double_indirect = NULL - - def __init__(self, iterable_or_len, _, double_indirect: bool = False): - if not isinstance(iterable_or_len, int): - for i, x in enumerate(iterable_or_len): - self[i] = x - - def __dealloc__(self): - libc.stdlib.free(self.double_indirect) - fmpz_mpoly_vec_clear(self.val, self.ctx.val) - - def __getitem__(self, x): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.val.length: - raise IndexError("index out of range") - - cdef fmpz_mpoly z = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_set(z.val, fmpz_mpoly_vec_entry(self.val, x), self.ctx.val) - return z - - def __setitem__(self, x, y): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.val.length: - raise IndexError("index out of range") - elif not typecheck(y, fmpz_mpoly): - raise TypeError("argument is not fmpz_mpoly") - elif (y).ctx is not self.ctx: - raise IncompatibleContextError(f"{(y).ctx} is not {self.ctx}") - - fmpz_mpoly_set( - fmpz_mpoly_vec_entry(self.val, x), (y).val, self.ctx.val - ) - - def __len__(self): - return self.val.length - - def __str__(self): - s = [None] * self.val.length - for i in range(self.val.length): - x = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_set(x.val, fmpz_mpoly_vec_entry(self.val, i), self.ctx.val) - s[i] = str(x) - return f"[{', '.join(s)}]" - - def __repr__(self): - return f"fmpz_mpoly_vec({self}, ctx={self.ctx})" - - def __richcmp__(self, other, int op): - if not (op == Py_EQ or op == Py_NE): - return NotImplemented - elif typecheck(other, fmpz_mpoly_vec): - if ( - (self).ctx is (other).ctx - and len(self) == len(other) - ): - return (op == Py_NE) ^ all(x == y for x, y in zip(self, other)) - else: - return op == Py_NE - else: - return NotImplemented - - def __iter__(self): - cdef fmpz_mpoly z - for i in range(self.val.length): - z = create_fmpz_mpoly(self.ctx) - fmpz_mpoly_set(z.val, fmpz_mpoly_vec_entry(self.val, i), self.ctx.val) - yield z - - def is_groebner(self, other=None) -> bool: - """ - Check if self is a Gröbner basis. If ``other`` is not None then check if self - is a Gröbner basis for ``other``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**2 - y - >>> g = x**3 - x - >>> k = x*y - x - >>> h = y**2 - y - >>> vec = fmpz_mpoly_vec([f, k, h], ctx) - >>> vec.is_groebner() - True - >>> vec.is_groebner(fmpz_mpoly_vec([f, g], ctx)) - True - >>> vec.is_groebner(fmpz_mpoly_vec([f, x**3], ctx)) - False - """ - if other is None: - return fmpz_mpoly_vec_is_groebner(self.val, NULL, self.ctx.val) - elif typecheck(other, fmpz_mpoly_vec): - self.ctx.compatible_context_check((other).ctx) - return fmpz_mpoly_vec_is_groebner( - self.val, (other).val, self.ctx.val - ) - else: - raise TypeError( - f"expected either None or a fmpz_mpoly_vec, got {type(other)}" - ) - - def is_autoreduced(self) -> bool: - """ - Check if self is auto-reduced (or inter-reduced). - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f2 = 3*x**2 - y - >>> k = x*y - x - >>> k2 = 3*x*y - 3*x - >>> h = y**2 - y - >>> vec = fmpz_mpoly_vec([f2, k, h], ctx) - >>> vec.is_autoreduced() - True - >>> vec = fmpz_mpoly_vec([f2, k2, h], ctx) - >>> vec.is_autoreduced() - False - - """ - return fmpz_mpoly_vec_is_autoreduced(self.val, self.ctx.val) - - def autoreduction(self, groebner=False) -> fmpz_mpoly_vec: - """ - Compute the autoreduction of ``self``. If ``groebner`` is True and ``self`` is a - Gröbner basis, compute the reduced reduced Gröbner basis of ``self``, throws an - ``RuntimeError`` otherwise. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f2 = 3*x**2 - y - >>> k2 = 3*x*y - 3*x - >>> h = y**2 - y - >>> vec = fmpz_mpoly_vec([f2, k2, h], ctx) - >>> vec.is_autoreduced() - False - >>> vec2 = vec.autoreduction() - >>> vec2.is_autoreduced() - True - >>> vec2 - fmpz_mpoly_vec([3*x^2 - y, x*y - x, y^2 - y], ctx=fmpz_mpoly_ctx(2, '', ('x', 'y'))) - """ - - cdef fmpz_mpoly_vec h = fmpz_mpoly_vec(0, self.ctx) - - if groebner: - if not self.is_groebner(): - raise RuntimeError( - "reduced Gröbner basis construction requires that ``self`` is a " - "Gröbner basis." - ) - fmpz_mpoly_vec_autoreduction_groebner(h.val, self.val, self.ctx.val) - else: - fmpz_mpoly_vec_autoreduction(h.val, self.val, self.ctx.val) - - return h - - def buchberger_naive(self, limits=None): - """ - Compute the Gröbner basis of ``self`` using a naive implementation of - Buchberger’s algorithm. - - Provide ``limits`` in the form of a tuple of ``(ideal_len_limit, poly_len_limit, - poly_bits_limit)`` to halt execution if the length of the ideal basis set exceeds - ``ideal_len_limit``, the length of any polynomial exceeds ``poly_len_limit``, or the - size of the coefficients of any polynomial exceeds ``poly_bits_limit``. - - If limits is provided return a tuple of ``(result, success)``. If ``success`` is - False then ``result`` is a valid basis for ``self``, but it may not be a Gröbner - basis. - - NOTE: This function is exposed only for convenience, it is a naive - implementation and does not compute a reduced basis. To construct a reduced - basis use ``autoreduce``. - - >>> ctx = fmpz_mpoly_ctx.get(('x', 'y'), 'lex') - >>> x, y = ctx.gens() - >>> f = x**2 - y - >>> g = x**3*y - x - >>> vec = fmpz_mpoly_vec([f, g], ctx) - >>> vec.is_groebner() - False - >>> vec2 = vec.buchberger_naive() - >>> vec2 - fmpz_mpoly_vec([x^2 - y, x^3*y - x, x*y^2 - x, y^3 - y], ctx=fmpz_mpoly_ctx(2, '', ('x', 'y'))) - >>> vec.buchberger_naive(limits=(2, 2, 512)) - (fmpz_mpoly_vec([x^2 - y, x^3*y - x], ctx=fmpz_mpoly_ctx(2, '', ('x', 'y'))), False) - >>> vec2.is_autoreduced() - False - >>> vec2.autoreduction() - fmpz_mpoly_vec([x^2 - y, y^3 - y, x*y^2 - x], ctx=fmpz_mpoly_ctx(2, '', ('x', 'y'))) - """ - - cdef: - fmpz_mpoly_vec g = fmpz_mpoly_vec(0, self.ctx) - slong ideal_len_limit, poly_len_limit, poly_bits_limit - - if limits is not None: - ideal_len_limit, poly_len_limit, poly_bits_limit = limits - if fmpz_mpoly_buchberger_naive_with_limits( - g.val, - self.val, - ideal_len_limit, - poly_len_limit, - poly_bits_limit, - self.ctx.val - ): - return g, True - else: - return g, False - else: - fmpz_mpoly_buchberger_naive(g.val, self.val, self.ctx.val) - return g diff --git a/src/flint/types/fmpz_poly.pxd b/src/flint/types/fmpz_poly.pxd deleted file mode 100644 index 253622ea..00000000 --- a/src/flint/types/fmpz_poly.pxd +++ /dev/null @@ -1,12 +0,0 @@ -from flint.flint_base.flint_base cimport flint_poly - -from flint.flintlib.functions.fmpz_poly cimport fmpz_poly_t - -cdef fmpz_poly_set_list(fmpz_poly_t poly, list val) - -cdef any_as_fmpz_poly(x) - -cdef class fmpz_poly(flint_poly): - cdef fmpz_poly_t val - cpdef long length(self) - cpdef long degree(self) diff --git a/src/flint/types/fmpz_poly.pyi b/src/flint/types/fmpz_poly.pyi deleted file mode 100644 index 75612f8c..00000000 --- a/src/flint/types/fmpz_poly.pyi +++ /dev/null @@ -1,93 +0,0 @@ -from typing import overload, Any, Sequence -from flint.flint_base.flint_base import flint_poly -from flint.types.fmpz import fmpz, ifmpz -from flint.types.fmpq import fmpq -from flint.types.fmpq_poly import fmpq_poly - -ifmpz_poly = fmpz_poly | ifmpz - -class fmpz_poly(flint_poly[fmpz]): - """ - The *fmpz_poly* type represents dense univariate polynomials over - the integers. - """ - - def __init__(self, arg: Sequence[ifmpz] | ifmpz_poly = ..., /) -> None: ... - def __len__(self) -> int: ... - def length(self) -> int: ... - def degree(self) -> int: ... - def __getitem__(self, i: int, /) -> fmpz: ... - def __setitem__(self, i: int, x: ifmpz, /) -> None: ... - def repr(self) -> str: ... - def __bool__(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_constant(self) -> bool: ... - def is_gen(self) -> bool: ... - def leading_coefficient(self) -> fmpz: ... - @overload - def __call__(self, other: ifmpz, /) -> fmpz: ... - @overload - def __call__(self, other: fmpq, /) -> fmpq: ... - @overload - def __call__(self, other: fmpz_poly, /) -> fmpz_poly: ... - @overload - def __call__(self, other: fmpq_poly, /) -> fmpq_poly: ... - # @overload - # def __call__(self, other: arb, /) -> acb: ... - # @overload - # def __call__(self, other: acb, /) -> acb: ... - def derivative(self) -> fmpz_poly: ... - def __pos__(self) -> fmpz_poly: ... - def __neg__(self) -> fmpz_poly: ... - def __add__(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def __radd__(self, other: ifmpz, /) -> fmpz_poly: ... - def __sub__(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def __rsub__(self, other: ifmpz, /) -> fmpz_poly: ... - def __mul__(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def __rmul__(self, other: ifmpz, /) -> fmpz_poly: ... - def __truediv__(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def __rtruediv__(self, other: ifmpz, /) -> fmpz_poly: ... - def __floordiv__(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def __rfloordiv__(self, other: ifmpz, /) -> fmpz_poly: ... - def __mod__(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def __rmod__(self, other: ifmpz, /) -> fmpz_poly: ... - def __divmod__(self, other: ifmpz_poly, /) -> tuple[fmpz_poly, fmpz_poly]: ... - def __rdivmod__(self, other: ifmpz, /) -> tuple[fmpz_poly, fmpz_poly]: ... - def __pow__(self, other: int, /) -> fmpz_poly: ... - - def left_shift(self, n: int, /) -> fmpz_poly: ... - def right_shift(self, n: int, /) -> fmpz_poly: ... - def truncate(self, n: int, /) -> fmpz_poly: ... - def mul_low(self, other: fmpz_poly, n: int) -> fmpz_poly: ... - def pow_trunc(self, e: int, n: int) -> fmpz_poly: ... - - def gcd(self, other: ifmpz_poly, /) -> fmpz_poly: ... - def content(self) -> fmpz: ... - def discriminant(self) -> fmpz: ... - def resultant(self, other: ifmpz_poly, /) -> fmpz: ... - def factor(self) -> tuple[fmpz, list[tuple[fmpz_poly, int]]]: ... - def factor_squarefree(self) -> tuple[fmpz, list[tuple[fmpz_poly, int]]]: ... - def sqrt(self) -> fmpz_poly: ... - def deflation(self) -> tuple[fmpz_poly, int]: ... - def deflation_monom(self) -> tuple[fmpz_poly, int, fmpz_poly]: ... - def inflate(self, n: int, /) -> fmpz_poly: ... - def deflate(self, n: int, /) -> fmpz_poly: ... - def deflation_index(self) -> tuple[int, int]: ... - - # XXX acb - def complex_roots(self, verbose: bool = False) -> list[Any]: ... - @staticmethod - def cyclotomic(n: int, /) -> fmpz_poly: ... - def is_cyclotomic(self) -> int: ... - @staticmethod - def cos_minpoly(n: int, /) -> fmpz_poly: ... - @staticmethod - def chebyshev_t(n: int, /) -> fmpz_poly: ... - @staticmethod - def chebyshev_u(n: int, /) -> fmpz_poly: ... - @staticmethod - def swinnerton_dyer(n: int, /, use_arb: bool = True) -> fmpz_poly: ... - @staticmethod - def hilbert_class_poly(D: int, /) -> fmpz_poly: ... - def height_bits(self, signed: bool = False) -> int: ... diff --git a/src/flint/types/fmpz_poly.pyx b/src/flint/types/fmpz_poly.pyx deleted file mode 100644 index 19628517..00000000 --- a/src/flint/types/fmpz_poly.pyx +++ /dev/null @@ -1,978 +0,0 @@ -from cpython.list cimport PyList_Size as PyList_GET_SIZE -from cpython.long cimport PyLong_Check - -cimport libc.stdlib - -from flint.flint_base.flint_context cimport getprec -from flint.flint_base.flint_base cimport flint_poly -from flint.utils.typecheck cimport typecheck -from flint.types.fmpz cimport fmpz_set_python -from flint.types.fmpz cimport any_as_fmpz -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport any_as_fmpq -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.fmpq_poly cimport any_as_fmpq_poly -from flint.types.acb cimport acb -from flint.types.arb cimport any_as_arb_or_notimplemented -from flint.types.arb cimport arb -from flint.types.acb cimport any_as_acb_or_notimplemented -from flint.flintlib.functions.fmpz cimport fmpz_init, fmpz_clear, fmpz_set -from flint.flintlib.functions.fmpz cimport fmpz_is_zero, fmpz_is_one, fmpz_equal_si, fmpz_equal -from flint.flintlib.functions.acb_modular cimport * -from flint.flintlib.functions.ulong_extras cimport n_is_prime -from flint.flintlib.functions.fmpz_poly cimport * -from flint.flintlib.functions.fmpz_poly_factor cimport * -from flint.flintlib.functions.arith cimport * -from flint.flintlib.types.arith cimport arith_chebyshev_t_polynomial, arith_chebyshev_u_polynomial -from flint.flintlib.functions.acb cimport * -from flint.flintlib.functions.arb_poly cimport * -from flint.flintlib.functions.arb_fmpz_poly cimport * -from flint.flintlib.functions.fmpz_vec cimport _fmpz_vec_content - -from flint.utils.flint_exceptions import DomainError - - -cdef any_as_fmpz_poly(x): - cdef fmpz_poly res - if typecheck(x, fmpz_poly): - return x - elif typecheck(x, fmpz): - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_set_fmpz(res.val, (x).val) - return res - elif PyLong_Check(x): - res = fmpz_poly.__new__(fmpz_poly) - t = fmpz(x) - fmpz_poly_set_fmpz(res.val, (t).val) - return res - return NotImplemented - -cdef fmpz_poly_set_list(fmpz_poly_t poly, list val): - cdef long i, n - cdef fmpz_t x - n = PyList_GET_SIZE(val) - fmpz_poly_fit_length(poly, n) - fmpz_init(x) - for i from 0 <= i < n: - if typecheck(val[i], fmpz): - fmpz_poly_set_coeff_fmpz(poly, i, ((val[i])).val) - elif fmpz_set_python(x, val[i]): - fmpz_poly_set_coeff_fmpz(poly, i, x) - else: - fmpz_clear(x) - raise TypeError("unsupported coefficient in list") - fmpz_clear(x) - -cdef class fmpz_poly(flint_poly): - """ - The *fmpz_poly* type represents dense univariate polynomials over - the integers. - - >>> fmpz_poly([1,2,3]) ** 3 - 27*x^6 + 54*x^5 + 63*x^4 + 44*x^3 + 21*x^2 + 6*x + 1 - >>> divmod(fmpz_poly([2,0,1,1,6]), fmpz_poly([3,5,7])) - (0, 6*x^4 + x^3 + x^2 + 2) - """ - - def __cinit__(self): - fmpz_poly_init(self.val) - - def __dealloc__(self): - fmpz_poly_clear(self.val) - - def __init__(self, *args): - if not args: - return - elif len(args) == 1: - val = args[0] - else: - raise TypeError("fmpz_poly() takes 0 or 1 arguments") - if typecheck(val, fmpz_poly): - fmpz_poly_set(self.val, (val).val) - elif isinstance(val, list): - fmpz_poly_set_list(self.val, val) - elif (v := any_as_fmpz(val)) is not NotImplemented: - fmpz_poly_set_fmpz(self.val, (v).val) - else: - raise TypeError("cannot create fmpz_poly from input of type %s", type(val)) - - def __len__(self): - return fmpz_poly_length(self.val) - - cpdef long length(self): - return fmpz_poly_length(self.val) - - cpdef long degree(self): - return fmpz_poly_degree(self.val) - - def __richcmp__(self, other, int op): - cdef bint r - if op != 2 and op != 3: - raise TypeError("polynomials cannot be ordered") - self = any_as_fmpz_poly(self) - if self is NotImplemented: - return self - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - r = fmpz_poly_equal((self).val, (other).val) - if op == 3: - r = not r - return r - - def __getitem__(self, long i): - cdef fmpz x - x = fmpz() - if i < 0: - return x - fmpz_poly_get_coeff_fmpz(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - v = fmpz(x) # XXX - fmpz_poly_set_coeff_fmpz(self.val, i, (v).val) - - def repr(self): - return "fmpz_poly([%s])" % (", ".join(map(str, self.coeffs()))) - - def __bool__(self): - return not fmpz_poly_is_zero(self.val) - - def is_zero(self): - """ - True if this polynomial is the zero polynomial. - - >>> fmpz_poly([]).is_zero() - True - """ - return fmpz_poly_is_zero(self.val) - - def is_one(self): - """ - True if this polynomial is equal to one. - - >>> fmpz_poly([2]).is_one() - False - """ - return fmpz_poly_is_one(self.val) - - def is_constant(self): - """ - True if this is a constant polynomial. - - >>> x = fmpz_poly([0, 1]) - >>> two = fmpz_poly([2]) - >>> x.is_constant() - False - >>> two.is_constant() - True - """ - return fmpz_poly_degree(self.val) <= 0 - - def is_gen(self): - """ - Return ``True`` if the polynomial is the generator - of the polynomial, `x`, and ``False`` otherwise - - >>> x = fmpz_poly([0, 1]) - >>> x - x - >>> x.is_gen() - True - >>> (x + 1).is_gen() - False - """ - return fmpz_poly_is_gen(self.val) - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then a copy of ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> f = fmpz_poly([1,2,3]) - >>> f.truncate(3) == f - True - >>> f.truncate(2) - 2*x + 1 - >>> f.truncate(1) - 1 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - - """ - cdef fmpz_poly res - res = fmpz_poly.__new__(fmpz_poly) - - length = fmpz_poly_length(self.val) - if n <= 0: # return zero - return res - elif n > length: # do nothing - fmpz_poly_set(res.val, self.val) - else: - fmpz_poly_set_trunc(res.val, self.val, n) - - return res - - def leading_coefficient(self): - """ - Returns the leading coefficient of the polynomial. - - >>> f = fmpz_poly([1, 2, 3]) - >>> f - 3*x^2 + 2*x + 1 - >>> f.leading_coefficient() - 3 - """ - cdef fmpz x - cdef slong d - d = fmpz_poly_degree(self.val) - x = fmpz.__new__(fmpz) - if d >= 0: - fmpz_poly_get_coeff_fmpz(x.val, self.val, d) - return x - - def __call__(self, other): - t = any_as_fmpz(other) - if t is not NotImplemented: - v = fmpz.__new__(fmpz) - fmpz_poly_evaluate_fmpz((v).val, self.val, (t).val) - return v - t = any_as_fmpz_poly(other) - if t is not NotImplemented: - v = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_compose((v).val, self.val, (t).val) - return v - t = any_as_fmpq(other) - if t is not NotImplemented: - return fmpq_poly(self)(t) - t = any_as_fmpq_poly(other) - if t is not NotImplemented: - return fmpq_poly(self)(t) - t = any_as_arb_or_notimplemented(other) - if t is not NotImplemented: - v = arb.__new__(arb) - arb_fmpz_poly_evaluate_arb((v).val, self.val, (t).val, getprec()) - return v - t = any_as_acb_or_notimplemented(other) - if t is not NotImplemented: - v = acb.__new__(acb) - arb_fmpz_poly_evaluate_acb((v).val, self.val, (t).val, getprec()) - return v - raise TypeError("cannot call fmpz_poly with input of type %s", type(other)) - - def derivative(self): - cdef fmpz_poly res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_derivative(res.val, self.val) - return res - - def __pos__(self): - return self - - def __neg__(self): - cdef fmpz_poly res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_neg(res.val, self.val) - return res - - def _add_(self, other): - cdef fmpz_poly res - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_add(res.val, (self).val, (other).val) - return res - - def __add__(self, other): - return self._add_(other) - - def __radd__(self, other): - return self._add_(other) - - def __sub__(self, other): - cdef fmpz_poly res - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_sub(res.val, (self).val, (other).val) - return res - - def __rsub__(self, other): - cdef fmpz_poly res - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_sub(res.val, (other).val, (self).val) - return res - - def _mul_(self, other): - cdef fmpz_poly res - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_mul(res.val, (self).val, (other).val) - return res - - def __mul__(self, other): - return self._mul_(other) - - def __rmul__(self, other): - return self._mul_(other) - - def __truediv__(fmpz_poly self, other): - cdef fmpz_poly res - o = any_as_fmpz(other) - if o is NotImplemented: - o = any_as_fmpz_poly(other) - if o is NotImplemented: - return NotImplemented - if fmpz_poly_is_zero((o).val): - raise ZeroDivisionError("fmpz_poly division by 0") - res, r = self._divmod_(o) - if r: - raise DomainError("fmpz_poly division is not exact") - else: - if fmpz_is_zero((o).val): - raise ZeroDivisionError("fmpz_poly division by 0") - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_scalar_divexact_fmpz(res.val, self.val, (o).val) - # Check division is exact - there should be a better way to do this - if res * o != self: - raise DomainError("fmpz_poly division is not exact") - return res - - def __rtruediv__(fmpz_poly self, other): - o = any_as_fmpz_poly(other) - if o is NotImplemented: - return NotImplemented - return o / self - - def _floordiv_(self, other): - cdef fmpz_poly res - if fmpz_poly_is_zero((other).val): - raise ZeroDivisionError("fmpz_poly division by 0") - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_div(res.val, (self).val, (other).val) - return res - - def __floordiv__(self, other): - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - return self._floordiv_(other) - - def __rfloordiv__(self, other): - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - return other._floordiv_(self) - - def _mod_(self, other): - cdef fmpz_poly res - if fmpz_poly_is_zero((other).val): - raise ZeroDivisionError("fmpz_poly division by 0") - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_rem(res.val, (self).val, (other).val) - return res - - def __mod__(self, other): - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - return self._mod_(other) - - def __rmod__(self, other): - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - return other._mod_(self) - - def _divmod_(self, other): - cdef fmpz_poly P, Q - if fmpz_poly_is_zero((other).val): - raise ZeroDivisionError("fmpz_poly divmod by 0") - P = fmpz_poly.__new__(fmpz_poly) - Q = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_divrem(P.val, Q.val, (self).val, (other).val) - return P, Q - - def __divmod__(self, other): - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - return self._divmod_(other) - - def __rdivmod__(self, other): - other = any_as_fmpz_poly(other) - if other is NotImplemented: - return other - return other._divmod_(self) - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> f = fmpz_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 - - """ - cdef fmpz_poly res - res = fmpz_poly.__new__(fmpz_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - fmpz_poly_shift_left(res.val, self.val, n) - else: # do nothing, just copy self - fmpz_poly_set(res.val, self.val) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> f = fmpz_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 - """ - cdef fmpz_poly res - res = fmpz_poly.__new__(fmpz_poly) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - fmpz_poly_shift_right(res.val, self.val, n) - else: # do nothing, just copy self - fmpz_poly_set(res.val, self.val) - - return res - - def __pow__(fmpz_poly self, exp, mod): - cdef fmpz_poly res - if mod is not None: - raise NotImplementedError("fmpz_poly modular exponentiation") - if exp < 0: - if not fmpz_poly_is_unit(self.val): - raise DomainError("fmpz_poly negative exponent, non-unit base") - exp = -exp - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_pow(res.val, self.val, exp) - return res - - def mul_low(self, other, slong n): - r""" - Returns the lowest ``n`` coefficients of the multiplication of ``self`` with ``other`` - - Equivalent to computing `f(x) \cdot g(x) \mod x^n` - - >>> f = fmpz_poly([2,3,5,7,11]) - >>> g = fmpz_poly([1,2,4,8,16]) - >>> f.mul_low(g, 5) - 101*x^4 + 45*x^3 + 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 3) - 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 1) - 2 - """ - # Only allow multiplication with other fmpz_poly - if not typecheck(other, fmpz_poly): - raise TypeError("other polynomial must be of type fmpz_poly") - - cdef fmpz_poly res - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_mullow(res.val, self.val, (other).val, n) - return res - - def pow_trunc(self, e, slong n): - r""" - Returns ``self`` raised to the power ``e`` modulo `x^n`: - :math:`f^e \mod x^n`/ - - >>> f = fmpz_poly([1, 2, 3]) - >>> x = fmpz_poly([0, 1]) - >>> f.pow_trunc(2**20, 4) - 1537230871828889600*x^3 + 2199024304128*x^2 + 2097152*x + 1 - >>> f.pow_trunc(5**25, 3) - 177635683940025046765804290771484375*x^2 + 596046447753906250*x + 1 - """ - if e < 0: - raise ValueError("Exponent must be non-negative") - - cdef slong e_c - cdef fmpz_poly res, tmp - - try: - e_c = e - except OverflowError: - # Exponent does not fit slong - res = fmpz_poly.__new__(fmpz_poly) - tmp = fmpz_poly.__new__(fmpz_poly) - ebytes = e.to_bytes((e.bit_length() + 15) // 16 * 2, "big") - fmpz_poly_pow_trunc(res.val, self.val, ebytes[0] * 256 + ebytes[1], n) - for i in range(2, len(ebytes), 2): - fmpz_poly_pow_trunc(res.val, res.val, 1 << 16, n) - fmpz_poly_pow_trunc(tmp.val, self.val, ebytes[i] * 256 + ebytes[i+1], n) - fmpz_poly_mullow(res.val, res.val, tmp.val, n) - return res - - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_pow_trunc(res.val, self.val, e_c, n) - return res - - def gcd(self, other): - """ - Returns the greatest common divisor of self and other. - - >>> A = fmpz_poly([2,0,1,0,5]); B = fmpz_poly([2,3,4]) - >>> (A*B).gcd(B) - 4*x^2 + 3*x + 2 - - """ - cdef fmpz_poly res - other = any_as_fmpz_poly(other) - if other is NotImplemented: - raise TypeError("cannot convert input to fmpz_poly") - res = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_gcd(res.val, self.val, (other).val) - return res - - def discriminant(self): - """ - Return the discriminant of ``self``. - - >>> f = fmpz_poly([1, 2, 3, 4, 5, 6]) - >>> f.discriminant() - 1037232 - >>> f = fmpz_poly([1, 3, 5, 7, 9, 11, 13]) - >>> f.discriminant() - -2238305839 - - """ - cdef fmpz res = fmpz.__new__(fmpz) - fmpz_poly_discriminant(res.val, self.val) - return res - - def resultant(self, other): - """ - Returns the resultant of *self* and *other*. - - >>> A = fmpz_poly([1, 0, -1]); B = fmpz_poly([1, -1]) - >>> A.resultant(B) - 0 - >>> C = fmpz_poly([1, 0, 0, 0, 0, -1, 1]) - >>> D = fmpz_poly([1, 0, 0, -1, 0, 0, 1]) - >>> C.resultant(D) - 3 - >>> f = fmpz_poly([1, -1] + [0] * 98 + [1]) - >>> g = fmpz_poly([1] + [0] * 50 + [-1] + [0] * 48 + [1]) - >>> f.resultant(g) - 1125899906842623 - - """ - cdef fmpz res - other = any_as_fmpz_poly(other) - if other is NotImplemented: - raise TypeError("cannot convert input to fmpz_poly") - - res = fmpz.__new__(fmpz) - fmpz_poly_resultant(res.val, self.val, (other).val) - return res - - def factor(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> (-73 * fmpz_poly([1,2,3]) ** 3 * fmpz_poly([5,6,7,8,9]) ** 8).factor() - (-73, [(3*x^2 + 2*x + 1, 3), (9*x^4 + 8*x^3 + 7*x^2 + 6*x + 5, 8)]) - >>> fmpz_poly.chebyshev_t(6).factor() - (1, [(2*x^2 + (-1), 1), (16*x^4 + (-16)*x^2 + 1, 1)]) - >>> (fmpz_poly([-1,1])**100).factor() - (1, [(x + (-1), 100)]) - >>> fmpz_poly([1,2,3,4,5,6]).factor() - (1, [(6*x^5 + 5*x^4 + 4*x^3 + 3*x^2 + 2*x + 1, 1)]) - - """ - return self._factor('irreducible') - - def factor_squarefree(self): - """ - Factors self into square-free factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> x = fmpz_poly([0, 1]) - >>> p = (-3 * x**2 * (x + 1)**2 * (x - 1)**3) - >>> p.factor_squarefree() - (-3, [(x^2 + x, 2), (x + (-1), 3)]) - >>> p.factor() - (-3, [(x, 2), (x + 1, 2), (x + (-1), 3)]) - - """ - return self._factor('squarefree') - - def _factor(self, factor_type): - cdef fmpz_poly_factor_t fac - cdef int i - fmpz_poly_factor_init(fac) - - if factor_type == 'squarefree': - fmpz_poly_factor_squarefree(fac, self.val) - elif factor_type == 'irreducible': - fmpz_poly_factor(fac, self.val) - else: - assert False - - res = [0] * fac.num - for 0 <= i < fac.num: - u = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_set((u).val, &fac.p[i]) - exp = fac.exp[i] - res[i] = (u, exp) - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.c) - fmpz_poly_factor_clear(fac) - - return c, res - - def complex_roots(self, bint verbose=False): - """ - Computes all the complex roots of this polynomial. - Returns a list of pairs (*c*, *m*) where *c* is the root - as an *acb* and *m* is the multiplicity of the root. - - >>> from flint import fmpz_poly, ctx - >>> ctx.prec = 53 - - >>> fmpz_poly([]).complex_roots() - [] - >>> fmpz_poly([1]).complex_roots() - [] - >>> fmpz_poly([2,0,1]).complex_roots() - [([1.41421356237310 +/- 4.96e-15]j, 1), ([-1.41421356237310 +/- 4.96e-15]j, 1)] - >>> for c, m in (fmpz_poly([2,3,4]) * fmpz_poly([5,6,7,11])**3).complex_roots(): - ... print(f'{float(c.real)} + {float(c.imag)}*j : {m}') - ... - -0.375 + 0.5994789404140899*j : 1 - -0.375 + -0.5994789404140899*j : 1 - -0.7352847274048426 + 0.0*j : 3 - 0.04946054552060311 + 0.7846931676471847*j : 3 - 0.04946054552060311 + -0.7846931676471847*j : 3 - - """ - cdef fmpz_poly_factor_t fac - cdef long deg, i, j - cdef int exp, flags - cdef acb_ptr croots - if not self: - return [] - flags = 0 - if verbose: - flags = 1 - roots = [] - fmpz_poly_factor_init(fac) - fmpz_poly_factor_squarefree(fac, self.val) - for 0 <= i < fac.num: - deg = fmpz_poly_degree(&fac.p[i]) - exp = fac.exp[i] - croots = _acb_vec_init(deg) - arb_fmpz_poly_complex_roots(croots, &fac.p[i], flags, getprec()) - for 0 <= j < deg: - v = acb() - acb_set(v.val, &croots[j]) - roots.append((v, exp)) - _acb_vec_clear(croots, deg) - fmpz_poly_factor_clear(fac) - return roots - - @staticmethod - def cyclotomic(ulong n): - r""" - Returns the cyclotomic polynomial `\Phi_n(x)` as an *fmpz_poly*. - - >>> fmpz_poly.cyclotomic(12) - x^4 + (-1)*x^2 + 1 - - """ - u = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_cyclotomic((u).val, n) - return u - - @staticmethod - def cos_minpoly(ulong n): - r""" - Returns the monic polynomial of `2 \cos(2 \pi / n)` as an *fmpz_poly*. - - >>> fmpz_poly.cos_minpoly(7) - x^3 + x^2 + (-2)*x + (-1) - - """ - u = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_cos_minpoly((u).val, n) - return u - - @staticmethod - def chebyshev_t(n): - r""" - Returns the Chebyshev polynomial of the first kind `T_n(x)` - as an *fmpz_poly*. - - >>> fmpz_poly.chebyshev_t(3) - 4*x^3 + (-3)*x - - """ - cdef fmpz_poly v = fmpz_poly() - arith_chebyshev_t_polynomial(v.val, n) - return v - - @staticmethod - def chebyshev_u(n): - r""" - Returns the Chebyshev polynomial of the second kind `U_n(x)` - as an *fmpz_poly*. - - >>> fmpz_poly.chebyshev_u(3) - 8*x^3 + (-4)*x - - """ - cdef fmpz_poly v = fmpz_poly() - arith_chebyshev_u_polynomial(v.val, n) - return v - - @staticmethod - def swinnerton_dyer(ulong n, bint use_arb=True): - r""" - Returns the Swinnerton-Dyer polynomial `S_n(x)` as an *fmpz_poly*. - Warning: the degree is `2^n`. - - >>> fmpz_poly.swinnerton_dyer(0) - x - >>> fmpz_poly.swinnerton_dyer(1) - x^2 + (-2) - >>> fmpz_poly.swinnerton_dyer(2) - x^4 + (-10)*x^2 + 1 - >>> fmpz_poly.swinnerton_dyer(3) - x^8 + (-40)*x^6 + 352*x^4 + (-960)*x^2 + 576 - - """ - cdef arb_poly_t t - if n > 20: - raise OverflowError("that's way too large...") - u = fmpz_poly.__new__(fmpz_poly) - if use_arb: - arb_poly_init(t) - arb_poly_swinnerton_dyer_ui(t, n, 0) - if not arb_poly_get_unique_fmpz_poly((u).val, t): - arb_poly_clear(t) - raise ValueError("insufficient precision") - arb_poly_clear(t) - else: - fmpz_poly_swinnerton_dyer((u).val, n) - return u - - @staticmethod - def hilbert_class_poly(slong D): - r""" - Returns the Hilbert class polynomial `H_D(x)` as an *fmpz_poly*. - - >>> fmpz_poly.hilbert_class_poly(-3) - x - >>> fmpz_poly.hilbert_class_poly(-4) - x + (-1728) - >>> fmpz_poly.hilbert_class_poly(-59) - x^3 + 30197678080*x^2 + (-140811576541184)*x + 374643194001883136 - >>> fmpz_poly.hilbert_class_poly(-5) - Traceback (most recent call last): - ... - ValueError: D must be an imaginary quadratic discriminant - """ - cdef fmpz_poly v = fmpz_poly() - acb_modular_hilbert_class_poly(v.val, D) - if fmpz_poly_length(v.val) == 0: - raise ValueError("D must be an imaginary quadratic discriminant") - return v - - def height_bits(self, bint signed=False): - if signed: - return fmpz_poly_max_bits(self.val) - else: - return abs(fmpz_poly_max_bits(self.val)) - - def sqrt(self): - cdef fmpz_poly v = fmpz_poly() - if fmpz_poly_sqrt(v.val, self.val): - return v - else: - raise DomainError(f"Cannot compute square root of {self}") - - def inflate(self, n: int) -> fmpz_poly: - """ - Compute the inflation of ``self`` for a provided ``n``, that is return ``q`` - such that ``q(x) = p(x^n)``. - - >>> f = fmpz_poly([1, 1]) - >>> f.inflate(2) - x^2 + 1 - """ - cdef fmpz_poly res = fmpz_poly() - fmpz_poly_inflate(res.val, self.val, n) - return res - - def deflate(self, n: int) -> fmpz_poly: - """ - Compute the deflation of ``self`` for a provided ``n``, that is return ``q`` - such that ``q(x) = p(x^(1/n))``. - - >>> f = fmpz_poly([1, 0, 1]) - >>> f.deflate(2) - x + 1 - """ - cdef fmpz_poly res = fmpz_poly() - if n > 0: - fmpz_poly_deflate(res.val, self.val, n) - return res - else: - raise ValueError("deflate requires n > 0") - - def deflation(self) -> tuple[fmpz_poly, int]: - """ - Compute the deflation of ``self``, that is ``p(x^(1/n))`` for maximal - n. returns ``q, n`` such that ``self == q.inflate(n)``. - - >>> f = fmpz_poly([1, 0, 1]) - >>> q, n = f.deflation() - >>> q, n - (x + 1, 2) - >>> q.inflate(n) == f - True - """ - cdef ulong n - if fmpz_poly_is_zero(self.val): - return self, 1 - n = fmpz_poly_deflation(self.val) - return self if n <= 1 else self.deflate(n), int(n) - - def deflation_monom(self) -> tuple[fmpz_poly, int, fmpz_poly]: - """ - Compute the exponent ``n`` and monomial ``m`` such that ``p(x^(1/n)) = m * - q(x^n)`` for maximal n. The returned monomial allows the undo-ing of the - deflation. - - >>> f = fmpz_poly([1, 0, 1]) - >>> f.deflation_monom() - (x^2 + 1, 1, x) - """ - n, m = self.deflation_index() - - cdef fmpz_poly monom = fmpz_poly.__new__(fmpz_poly) - cdef fmpz_poly res = fmpz_poly.__new__(fmpz_poly) - - fmpz_poly_set_coeff_ui(monom.val, m, 1) - fmpz_poly_deflate(res.val, self.val, n) - - return res, n, monom - - def deflation_index(self) -> tuple[int, int]: - """ - Compute the exponent ``n`` and ``i`` such that ``p(x^(1/n)) = x^i * - q(x^n)`` for maximal ``n``. Importantly the deflation itself is not computed - here. The returned exponent ``i`` is the shift that was applied to the - exponents. It is the exponent of the monomial returned by - ``deflation_monom``. - - >>> f = fmpz_poly([1, 0, 1]) - >>> f.deflation_index() - (1, 1) - """ - cdef fmpz_poly res = fmpz_poly.__new__(fmpz_poly) - cdef slong length = fmpz_poly_length(self.val) - - if length <= 0: - return self, 0, fmpz_poly([1]) - - # Find the smallest non-zero power, that is the gcd of the monomials - for i in range(1, length + 1): - if not fmpz_is_zero(&self.val.coeffs[length - i]): - break - - fmpz_poly_shift_right(res.val, self.val, i) - return int(fmpz_poly_deflation(res.val)), int(i) - - def is_cyclotomic(self): - cdef long * phi - cdef long i, p, q, d, N1, N2 - cdef double U - d = self.degree() - if d < 1: - return 0 - if d == 1: - if fmpz_is_one(fmpz_poly_get_coeff_ptr(self.val, 1)) and fmpz_equal_si(fmpz_poly_get_coeff_ptr(self.val, 0), -1): - return 1 - if fmpz_is_one(fmpz_poly_get_coeff_ptr(self.val, 1)) and fmpz_equal_si(fmpz_poly_get_coeff_ptr(self.val, 0), 1): - return 2 - return 0 - if d % 2 != 0: - return 0 - if not fmpz_is_one(fmpz_poly_get_coeff_ptr(self.val, 0)): - return 0 - for i in range(d//2): - if not fmpz_equal(fmpz_poly_get_coeff_ptr(self.val, i), fmpz_poly_get_coeff_ptr(self.val, d-i)): - return 0 - U = d - for p in range(2, d+1): - if d % (p-1) == 0: - if n_is_prime(p): - U = (U * p) / (p - 1) - N1 = d + 1 - N2 = int(U + 3) # +3 as safety for possible float roundoff - phi = libc.stdlib.malloc(N2 * sizeof(long)) - for i in range(N2): - phi[i] = i - for p in range(2, N2): - if phi[p] == p: - phi[p] = p - 1 - for q in range(2*p, N2, p): - phi[q] = (phi[q] // p) * (p-1) - for i in range(N1, N2): - if phi[i] == d: - v = fmpz_poly.cyclotomic(i) - if self == v: - return int(i) - libc.stdlib.free(phi) - return 0 - - def content(self): - """ - Return the GCD of the coefficients of ``self``. - - >>> fmpz_poly([3, 6, 0]).content() - 3 - """ - cdef fmpz res = fmpz() - _fmpz_vec_content(res.val, self.val.coeffs, self.val.length) - return res diff --git a/src/flint/types/fmpz_series.pxd b/src/flint/types/fmpz_series.pxd deleted file mode 100644 index 47b8ee7e..00000000 --- a/src/flint/types/fmpz_series.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series - -from flint.flintlib.functions.fmpz_poly cimport fmpz_poly_t - -cdef class fmpz_series(flint_series): - cdef fmpz_poly_t val - cdef long _prec - cpdef long length(self) - cpdef valuation(self) diff --git a/src/flint/types/fmpz_series.pyi b/src/flint/types/fmpz_series.pyi deleted file mode 100644 index c4f7f91c..00000000 --- a/src/flint/types/fmpz_series.pyi +++ /dev/null @@ -1,46 +0,0 @@ -from typing import Any, Sequence -from flint.flint_base.flint_base import flint_series -from flint.types.fmpz import fmpz, ifmpz -from flint.types.fmpz_poly import fmpz_poly, ifmpz_poly - - -ifmpz_series = fmpz_series | ifmpz_poly - - -class fmpz_series(flint_series[fmpz]): - - def __init__(self, - val: Sequence[ifmpz] | fmpz_series | fmpz_poly | ifmpz | None = None, - prec: int | None = None): ... - - @property - def prec(self) -> int: ... - - def _equal_repr(self, other: object) -> bool: ... - - def __len__(self) -> int: ... - def length(self) -> int: ... - - def __getitem__(self, i: int, /) -> fmpz: ... - def __setitem__(self, i: int, x: ifmpz, /) -> None: ... - - def repr(self, **kwargs: Any) -> str: ... - def str(self, **kwargs: Any) -> str: ... - - def __pos__(self) -> fmpz_series: ... - def __neg__(self) -> fmpz_series: ... - def __add__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __radd__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __sub__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __rsub__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __mul__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __rmul__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __truediv__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __rtruediv__(self, other: ifmpz_series, /) -> fmpz_series: ... - def __pow__(self, exp: int, /) -> fmpz_series: ... - - def valuation(self) -> int: ... - - def __call__(self, other: ifmpz_series, /) -> fmpz_series: ... - - def reversion(self) -> fmpz_series: ... diff --git a/src/flint/types/fmpz_series.pyx b/src/flint/types/fmpz_series.pyx deleted file mode 100644 index 07bc519d..00000000 --- a/src/flint/types/fmpz_series.pyx +++ /dev/null @@ -1,407 +0,0 @@ -from flint.utils.typecheck cimport typecheck -from flint.flint_base.flint_base cimport flint_series -from flint.flint_base.flint_context cimport getcap -from flint.types.fmpz_poly cimport fmpz_poly_set_list -from flint.types.fmpz cimport fmpz -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpq cimport fmpq -from flint.types.fmpq_poly cimport fmpq_poly -from flint.types.fmpq_series cimport fmpq_series -from flint.types.arb cimport arb -from flint.types.arb_poly cimport arb_poly -from flint.types.arb_series cimport arb_series -from flint.types.acb cimport acb -from flint.types.acb_poly cimport acb_poly -from flint.types.acb_series cimport acb_series - -from flint.flintlib.functions.fmpz cimport fmpz_is_zero, fmpz_is_pm1 -from flint.flintlib.functions.fmpz_poly cimport * - -cdef fmpz_series_coerce_operands(x, y): - if isinstance(y, (int, fmpz, fmpz_poly)): - return x, fmpz_series(y) - if isinstance(y, (fmpq, fmpq_poly, fmpq_series)): - return fmpq_series(x), fmpq_series(y) - # if isinstance(y, (nmod, nmod_poly, nmod_series)): - # return nmod_series(x), nmod_series(y) - if isinstance(y, (float, arb, arb_poly, arb_series)): - return arb_series(x), arb_series(y) - if isinstance(y, (complex, acb, acb_poly, acb_series)): - return acb_series(x), acb_series(y) - return NotImplemented, NotImplemented - -cdef class fmpz_series(flint_series): - """ - Power series with integer coefficients. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - >>> fmpz_series([1,2,3]) - 1 + 2*x + 3*x^2 + O(x^10) - >>> fmpz_series([1,2,3], prec=2) - 1 + 2*x + O(x^2) - >>> fmpz_series([1,2,3], prec=2) + fmpz_series([1,2,3,4,5]) - 2 + 4*x + O(x^2) - >>> a = fmpz_series([1,2,3]) - >>> (a+1)*(a-1) - a**2 + 1 - 0 + O(x^10) - - """ - - # cdef fmpz_poly_t val - # cdef long _prec - - def __cinit__(self): - fmpz_poly_init(self.val) - self._prec = 0 - - def __dealloc__(self): - fmpz_poly_clear(self.val) - - def __init__(self, val=None, prec=None): - if prec is None: - self._prec = getcap() - else: - self._prec = prec - if self._prec < 0: - self._prec = -1 - if val is not None: - if typecheck(val, fmpz_series): - fmpz_poly_set(self.val, (val).val) - self._prec = min((val)._prec, self._prec) - elif typecheck(val, fmpz_poly): - fmpz_poly_set(self.val, (val).val) - elif typecheck(val, list): - fmpz_poly_set_list(self.val, val) - else: - fmpz_poly_set_list(self.val, [val]) - fmpz_poly_truncate(self.val, max(0, self._prec)) - - @property - def prec(self): - """ - The term precision of the finitely approximated series. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - >>> s = fmpz_series([1,2]) - >>> s - 1 + 2*x + O(x^10) - >>> s.prec - 10 - >>> s2 = fmpz_series([1,2], prec=3) - >>> s2 - 1 + 2*x + O(x^3) - >>> s2.prec - 3 - """ - return self._prec - - def _equal_repr(self, other): - cdef bint r - if not typecheck(other, fmpz_series): - return False - r = fmpz_poly_equal((self).val, (other).val) - if r: - r = (self)._prec == (other)._prec - return r - - def __len__(self): - return fmpz_poly_length(self.val) - - cpdef long length(self): - return fmpz_poly_length(self.val) - - def __getitem__(self, long i): - cdef fmpz x - x = fmpz() - if i >= 0: - fmpz_poly_get_coeff_fmpz(x.val, self.val, i) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of series") - if not typecheck(x, fmpz): - x = fmpz(x) - fmpz_poly_set_coeff_fmpz(self.val, i, (x).val) - - def repr(self, **kwargs): - return "fmpz_series([%s], prec=%s)" % (", ".join(map(str, self)), self._prec) - - def str(self, **kwargs): - if self._prec > 0: - s = fmpz_poly(list(self)).str(ascending=True) - return s + (" + O(x^%s)" % self._prec) - elif self._prec == 0: - return "O(x^0)" - else: - return "(invalid power series)" - - def __pos__(self): - return self - - def __neg__(s): - cdef long cap - u = fmpz_series.__new__(fmpz_series) - cap = getcap() - cap = min(cap, (s)._prec) - if cap > 0: - fmpz_poly_neg((u).val, (s).val) - fmpz_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __add__(s, t): - if not isinstance(t, fmpz_series): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s + t - cdef long cap - u = fmpz_series.__new__(fmpz_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - fmpz_poly_add((u).val, (s).val, (t).val) - fmpz_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __radd__(s, t): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t + s - - def __sub__(s, t): - if not isinstance(t, fmpz_series): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s - t - cdef long cap - u = fmpz_series.__new__(fmpz_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - fmpz_poly_sub((u).val, (s).val, (t).val) - fmpz_poly_truncate((u).val, cap) - (u)._prec = cap - return u - - def __rsub__(s, t): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t - s - - def __mul__(s, t): - if not isinstance(t, fmpz_series): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s * t - cdef long cap - u = fmpz_series.__new__(fmpz_series) - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - if cap > 0: - fmpz_poly_mullow((u).val, (s).val, (t).val, cap) - (u)._prec = cap - return u - - def __rmul__(s, t): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t * s - - cpdef valuation(self): - """ - Returns the valuation of this power series. - If there are no known nonzero coefficients, returns -1. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - - >>> s1 = fmpz_series([1,2,3]) - >>> s1 - 1 + 2*x + 3*x^2 + O(x^10) - >>> s1.valuation() - 0 - - >>> s2 = fmpz_series([0,0,0,1,2,3]) - >>> s2 - x^3 + 2*x^4 + 3*x^5 + O(x^10) - >>> s2.valuation() - 3 - - >>> s3 = fmpz_series([]) - >>> s3 - 0 + O(x^10) - >>> s3.valuation() - -1 - - """ - cdef long i - if fmpz_poly_is_zero(self.val): - return -1 - i = 0 - while fmpz_is_zero(fmpz_poly_get_coeff_ptr(self.val, i)): - i += 1 - return i - - def _div_(s, t): - """ - Power series division. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - - >>> fmpz_series([1]) / fmpz_series([1,-1,-1]) - 1 + x + 2*x^2 + 3*x^3 + 5*x^4 + 8*x^5 + 13*x^6 + 21*x^7 + 34*x^8 + 55*x^9 + O(x^10) - >>> fmpz_series([0,1,2]) / fmpz_series([0,1,2]) - 1 + O(x^9) - >>> fmpz_series([1,2]) / fmpz_series([0,1,2]) - Traceback (most recent call last): - ... - ValueError: quotient would not be a power series - >>> fmpz_series([1,2]) / fmpz_series([2,3]) - Traceback (most recent call last): - ... - ValueError: leading term in denominator is not a unit - >>> fmpz_series([]) / fmpz_series([1,2,3], prec=5) - 0 + O(x^5) - - """ - cdef long cap, sval, tval - cdef fmpz_poly_t stmp, ttmp - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - - if fmpz_poly_is_zero((t).val): - raise ZeroDivisionError("power series division") - - u = fmpz_series.__new__(fmpz_series) - - if fmpz_poly_is_zero((s).val): - (u)._prec = cap - return u - - sval = (s).valuation() - tval = (t).valuation() - - if sval < tval: - raise ValueError("quotient would not be a power series") - - if not fmpz_is_pm1(fmpz_poly_get_coeff_ptr((t).val, tval)): - raise ValueError("leading term in denominator is not a unit") - - if tval == 0: - fmpz_poly_div_series((u).val, (s).val, (t).val, cap) - else: - fmpz_poly_init(stmp) - fmpz_poly_init(ttmp) - fmpz_poly_shift_right(stmp, (s).val, tval) - fmpz_poly_shift_right(ttmp, (t).val, tval) - cap -= tval - fmpz_poly_div_series((u).val, stmp, ttmp, cap) - fmpz_poly_clear(stmp) - fmpz_poly_clear(ttmp) - - (u)._prec = cap - return u - - def __truediv__(s, t): - if isinstance(t, fmpz_series): - return fmpz_series._div_(s, t) - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return s / t - - def __rtruediv__(s, t): - s, t = fmpz_series_coerce_operands(s, t) - if s is NotImplemented: - return s - return t / s - - def __pow__(fmpz_series s, ulong exp, mod): - """ - Power series exponentiation. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - >>> fmpz_series([3,4,5], prec=4) ** 5 - 243 + 1620*x + 6345*x^2 + 16560*x^3 + O(x^4) - """ - cdef long cap - if mod is not None: - raise NotImplementedError("fmpz_series modular exponentiation") - cap = getcap() - cap = min(cap, (s)._prec) - u = fmpz_series.__new__(fmpz_series) - fmpz_poly_pow_trunc((u).val, (s).val, exp, cap) - (u)._prec = cap - return u - - def __call__(s, t): - """ - Power series composition. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - >>> fmpz_series([1,2,3])(fmpz_series([0,1,2])) - 1 + 2*x + 7*x^2 + 12*x^3 + 12*x^4 + O(x^10) - >>> fmpz_series([1,2,3])(fmpz_series([1,1,2])) - Traceback (most recent call last): - ... - ValueError: power series composition with nonzero constant term - - """ - cdef long cap - if typecheck(t, fmpz_series): - u = fmpz_series.__new__(fmpz_series) - if (t).valuation() < 1: - raise ValueError("power series composition with nonzero constant term") - cap = getcap() - cap = min(cap, (s)._prec) - cap = min(cap, (t)._prec) - fmpz_poly_compose_series((u).val, (s).val, (t).val, cap) - (u)._prec = cap - return u - raise TypeError("cannot call fmpz_series with input of type %s", type(t)) - - def reversion(s): - """ - Power series reversion. - - >>> from flint import fmpz_series, ctx - >>> ctx.cap = 10 - - >>> fmpz_series([0,1,-2,-3]).reversion() - x + 2*x^2 + 11*x^3 + 70*x^4 + 503*x^5 + 3864*x^6 + 31092*x^7 + 258654*x^8 + 2206655*x^9 + O(x^10) - >>> fmpz_series([0,1,-2,-3]).reversion()(fmpz_series([0,1,-2,-3])) - x + O(x^10) - >>> fmpz_series([1,2,3]).reversion() - Traceback (most recent call last): - ... - ValueError: power series reversion must have valuation 1 - - """ - cdef long cap - cap = getcap() - cap = min(cap, (s)._prec) - if (s).valuation() != 1: - raise ValueError("power series reversion must have valuation 1") - if not fmpz_is_pm1(fmpz_poly_get_coeff_ptr((s).val, 1)): - raise ValueError("leading term is not a unit") - u = fmpz_series.__new__(fmpz_series) - fmpz_poly_revert_series((u).val, (s).val, cap) - (u)._prec = cap - return u diff --git a/src/flint/types/fmpz_vec.pxd b/src/flint/types/fmpz_vec.pxd deleted file mode 100644 index 4c36c77f..00000000 --- a/src/flint/types/fmpz_vec.pxd +++ /dev/null @@ -1,7 +0,0 @@ -from flint.flintlib.functions.fmpz cimport fmpz_struct -from flint.flintlib.types.flint cimport slong - -cdef class fmpz_vec: - cdef fmpz_struct *val - cdef fmpz_struct **double_indirect - cdef slong length diff --git a/src/flint/types/fmpz_vec.pyx b/src/flint/types/fmpz_vec.pyx deleted file mode 100644 index 0b76f01c..00000000 --- a/src/flint/types/fmpz_vec.pyx +++ /dev/null @@ -1,85 +0,0 @@ -from flint.flintlib.functions.fmpz cimport fmpz_struct, fmpz_set, fmpz_init_set -from flint.flintlib.functions.fmpz_vec cimport _fmpz_vec_init, _fmpz_vec_clear - -from flint.types.fmpz cimport fmpz, any_as_fmpz - -cimport libc.stdlib - -cdef class fmpz_vec: - def __cinit__(self, iterable_or_len, bint double_indirect=False): - if isinstance(iterable_or_len, int): - self.length = iterable_or_len - else: - self.length = len(iterable_or_len) - - self.val = _fmpz_vec_init(self.length) - - if double_indirect: - self.double_indirect = libc.stdlib.malloc(self.length * sizeof(fmpz_struct *)) - if self.double_indirect is NULL: - raise MemoryError("malloc returned a null pointer") - - for i in range(self.length): - self.double_indirect[i] = &self.val[i] - else: - self.double_indirect = NULL - - def __init__(self, iterable_or_len, double_indirect: bool = False): - if not isinstance(iterable_or_len, int): - for i, x in enumerate(iterable_or_len): - self[i] = x - - def __dealloc__(self): - libc.stdlib.free(self.double_indirect) - if self.val is not NULL: - _fmpz_vec_clear(self.val, self.length) - self.val = NULL - - def __getitem__(self, x): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - cdef fmpz z = fmpz.__new__(fmpz) - fmpz_init_set(z.val, &self.val[x]) - return z - - def __setitem__(self, x, y): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - y = any_as_fmpz(y) - if y is NotImplemented: - raise TypeError("argument is not coercible to fmpz") - - fmpz_set(&self.val[x], (y).val) - - def __len__(self): - return self.length - - def __str__(self): - return self.str() - - def __repr__(self): - return self.repr() - - def __iter__(self): - cdef fmpz z - for i in range(self.length): - z = fmpz.__new__(fmpz) - fmpz_init_set(z.val, &self.val[i]) - yield z - - def str(self, *args): - s = [None] * self.length - for i in range(self.length): - x = fmpz.__new__(fmpz) - fmpz_init_set(x.val, &self.val[i]) - s[i] = x.str(*args) - return str(s) - - def repr(self, *args): - return f"fmpz_vec({self.str(*args)}, {self.length})" diff --git a/src/flint/types/fq_default.pxd b/src/flint/types/fq_default.pxd deleted file mode 100644 index 53c2fe64..00000000 --- a/src/flint/types/fq_default.pxd +++ /dev/null @@ -1,51 +0,0 @@ -from flint.flintlib.functions.fq_default cimport * -from flint.types.fmpz cimport fmpz -from flint.flint_base.flint_base cimport flint_scalar - -cpdef enum fq_default_type: - """ - Enum for the fq_default context types: - - - 1. `fq_default_ctx.FQ_ZECH`: Use `fq_zech_t`, - - 2. `fq_default_ctx.FQ_NMOD`: Use `fq_nmod_t`, - - 3. `fq_default_ctx.FQ`: Use `fq_t`. - - 4. `fq_default_ctx.NMOD`: Use `nmod` for degree = 1, - - 5. `fq_default_ctx.FMPZ_MOD`: Use `fmpz_mod` for degree = 1. - - These can be manually selected, or type: `fq_default_ctx.DEFAULT` can be used - for the implementation to be automatically decided by Flint (default), - """ - DEFAULT = 0 - FQ_ZECH = 1 - FQ_NMOD = 2 - FQ = 3 - NMOD = 4 - FMPZ_MOD = 5 - -cdef class fq_default_ctx: - cdef fq_default_ctx_t val - cdef str var - cdef bint _initialized - - cdef new_ctype_fq_default(self) - cdef set_list_as_fq_default(self, fq_default_t val, obj) - cdef set_any_scalar_as_fq_default(self, fq_default_t fq_ele, obj) - cdef set_any_as_fq_default(self, fq_default_t val, obj) - cdef any_as_fq_default(self, obj) - - cdef _set_from_order(self, p, d, var, fq_type=*, check_prime=*) - cdef _set_from_modulus(self, modulus, var, fq_type=*, check_prime=*, check_modulus=*) - -cdef class fq_default(flint_scalar): - cdef fq_default_ctx ctx - cdef fq_default_t val - - # Arithmetic for flint_scalar base class - cpdef fq_default _neg_(fq_default self) - cpdef fq_default _add_(fq_default self, fq_default other) - cpdef fq_default _mul_(fq_default self, fq_default other) - cpdef fq_default _sub_(fq_default self, fq_default other) - cpdef fq_default _rsub_(fq_default self, fq_default other) - cpdef fq_default _div_(fq_default self, fq_default other) - cpdef fq_default _rdiv_(fq_default self, fq_default other) - cpdef fq_default _invert_(fq_default self) diff --git a/src/flint/types/fq_default.pyi b/src/flint/types/fq_default.pyi deleted file mode 100644 index c2993511..00000000 --- a/src/flint/types/fq_default.pyi +++ /dev/null @@ -1,74 +0,0 @@ -from enum import Enum -from ..flint_base.flint_base import flint_scalar -from .fmpz import fmpz -from .fmpz_mod import fmpz_mod, ifmpz -from .fmpz_poly import fmpz_poly -from .nmod_poly import nmod_poly -from .fmpz_mod_poly import fmpz_mod_poly - -class fq_default_type(Enum): - DEFAULT = 0 - FQ_ZECH = 1 - FQ_NMOD = 2 - FQ = 3 - NMOD = 4 - FMPZ_MOD = 5 - -ifmpz_mod = ifmpz | fmpz_mod -ifq_default = fq_default | fmpz_mod_poly | nmod_poly | fmpz_poly | ifmpz_mod - -class fq_default_ctx: - r"""Context object for creating :class:`~.fq_default`.""" - - def __init__( - self, - p: ifmpz | None = None, - degree: int | None = None, - var: str | None = None, - modulus: fmpz_mod_poly | fmpz_poly | None = None, - fq_type: str | int | fq_default_type = fq_default_type.DEFAULT, - check_prime: bool = True, - check_modulus: bool = True, - ): ... - @property - def fq_type(self) -> fq_default_type: ... - def degree(self) -> int: ... - def characteristic(self) -> fmpz: ... - def prime(self) -> fmpz: ... - def order(self) -> fmpz: ... - def multiplicative_order(self) -> fmpz: ... - def modulus(self) -> fmpz_mod_poly: ... - def zero(self) -> fq_default: ... - def one(self) -> fq_default: ... - def gen(self) -> fq_default: ... - def random_element(self, not_zero: bool = False) -> fq_default: ... - def __call__(self, val: ifq_default) -> fq_default: ... - -class fq_default(flint_scalar): - def __init__(self, val: list[ifmpz] | ifq_default, ctx: fq_default_ctx): ... - def __int__(self) -> int: ... - def polynomial(self) -> fmpz_mod_poly: ... - def to_list(self) -> list[ifmpz]: ... - def str(self) -> str: ... - def __hash__(self) -> int: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def inverse(self) -> fq_default: ... - def square(self) -> fq_default: ... - def __neg__(self) -> fq_default: ... - def __add__(self, other: ifq_default, /) -> fq_default: ... - def __radd__(self, other: ifq_default, /) -> fq_default: ... - def __sub__(self, other: ifq_default, /) -> fq_default: ... - def __rsub__(self, other: ifq_default, /) -> fq_default: ... - def __mul__(self, other: ifq_default, /) -> fq_default: ... - def __rmul__(self, other: ifq_default, /) -> fq_default: ... - def __truediv__(self, other: ifq_default, /) -> fq_default: ... - def __rtruediv__(self, other: ifq_default, /) -> fq_default: ... - def __invert__(self) -> fq_default: ... - def __pow__(self, e: ifmpz) -> fq_default: ... - def sqrt(self) -> fq_default: ... - def is_square(self) -> bool: ... - def pth_root(self) -> fq_default: ... - def trace(self) -> fmpz: ... - def norm(self) -> fmpz: ... - def frobenius(self, e: int = ...) -> fq_default: ... diff --git a/src/flint/types/fq_default.pyx b/src/flint/types/fq_default.pyx deleted file mode 100644 index c8478e5e..00000000 --- a/src/flint/types/fq_default.pyx +++ /dev/null @@ -1,836 +0,0 @@ -from flint.pyflint cimport global_random_state -from flint.types.fmpz cimport fmpz, any_as_fmpz -from flint.types.nmod cimport nmod -from flint.types.fmpz_mod cimport fmpz_mod -from flint.types.fmpz_poly cimport fmpz_poly, any_as_fmpz_poly, fmpz_poly_set_list -from flint.types.fmpz_mod_poly cimport fmpz_mod_poly, fmpz_mod_poly_ctx -from flint.types.nmod_poly cimport nmod_poly -from flint.utils.typecheck cimport typecheck - -from flint.utils.flint_exceptions import DomainError - -# Allow the type to be denoted by strings or integers -FQ_TYPES = { - "FQ_ZECH" : 1, - "FQ_NMOD" : 2, - "FQ" : 3, - "NMOD" : 4, - "FMPZ_MOD" : 5 -} - -cdef class fq_default_ctx: - r""" - Context object for creating :class:`~.fq_default`. - - Finite fields can be initialized in one of two possible ways. The - first is by providing characteristic and degree: - - >>> fq_default_ctx(5, 2, 'y', fq_type='FQ_ZECH') - fq_default_ctx(5, 2, 'y', x^2 + 4*x + 2, 'FQ_ZECH') - - The second is by giving an irreducible polynomial of type - :class:`~.nmod_poly` or :class:`~.fmpz_mod_poly`: - - >>> from flint import fmpz_mod_poly_ctx - >>> mod = fmpz_mod_poly_ctx(11)([1,0,1]) - >>> fq_default_ctx(modulus=mod, fq_type='FQ_NMOD') - fq_default_ctx(11, 2, 'z', x^2 + 1, 'FQ_NMOD') - - For more details, see the documentation of :method:`~._set_from_order` - and :method:`~._set_from_modulus`. - """ - def __cinit__(self): - pass - - def __dealloc__(self): - if self._initialized: - fq_default_ctx_clear(self.val) - self._initialized = False - - @staticmethod - def _parse_input_fq_type(fq_type): - if typecheck(fq_type, str): - fq_type = FQ_TYPES.get(fq_type, None) - if fq_type is None: - raise ValueError("invalid fq_type string") - - # Now fq_type should be an int between 0, 5 - if not typecheck(fq_type, int): - raise TypeError(f"fq_type = {fq_type} is invalid") - if fq_type < 0 or fq_type > 5: - raise ValueError(f"fq_type = {fq_type} should be between 0 and 5") - - return fq_type - - @staticmethod - def _parse_input_var(var) -> str: - # If no variable is given, use x - if var is None: - var = "z" - elif isinstance(var, bytes): - var = var.decode() - if len(var) < 1: - raise ValueError("variable for GF(p^k) generator must be at least one character") - return var - - def __init__(self, p=None, degree=None, var=None, modulus=None, fq_type=fq_default_type.DEFAULT, - check_prime=True, check_modulus=True): - # Ensure the var used for the generator of GF(p^d) is a single byte - var = self._parse_input_var(var) - self.var = var - - # Ensure the fq_type is an integer between 0, 5 -- we allow users to - # input a string which is converted as an enum - fq_type = self._parse_input_fq_type(fq_type) - - # If a modulus is given, attempt to construct from this - if modulus is not None: - # If the polynomial has no known characteristic, we can try and create one - # using the supplied prime - if not typecheck(modulus, fmpz_mod_poly): - if p is None: - raise ValueError("cannot create from modulus if no characteristic is known") - ring_ctx = fmpz_mod_poly_ctx(p) - if not ring_ctx.is_prime(): - raise ValueError("characteristic is not prime") - modulus = ring_ctx.any_as_fmpz_mod_poly(modulus) - if modulus is NotImplemented: - raise TypeError("modulus cannot be cast to fmpz_mod_poly") - - self._set_from_modulus(modulus, var, fq_type, check_prime=check_prime, check_modulus=check_modulus) - return - - # If there's no modulus and no prime, we can't continue - if p is None: - raise ValueError("either a prime or modulus must be passed for construction") - - # If we're not given a degree, construct GF(p) - if degree is None: - degree = 1 - - # Construct the field from the prime and degree GF(p^d) - self._set_from_order(p, degree, var, fq_type, check_prime=check_prime) - - cdef _set_from_order(self, p, d, var, fq_type=fq_default_type.DEFAULT, check_prime=True): - """ - Construct a context for the finite field GF(p^d). - - `var` is a name for the ring generator of this field over GF(p). - - The optional parameter `type` select the implementation. For more - information about the types available, see :class:`~.fq_default_type` - for possible types. - """ - # c_from_order expects the characteristic to be fmpz type - prime = any_as_fmpz(p) - if prime is NotImplemented: - raise TypeError(f"cannot coerce p = {p} to type fmpz") - - if check_prime and not prime.is_prime(): - raise ValueError("characteristic is not prime") - - # the degree must be strictly positive - if d < 1: - raise ValueError(f"the degree must be positive, got d = {d}") - - fq_default_ctx_init_type(self.val, (prime).val, d, self.var.encode(), fq_type) - self._initialized = True - - cdef _set_from_modulus(self, modulus, var, fq_type=fq_default_type.DEFAULT, - check_prime=True, check_modulus=True): - """ - Construct a context for a finite field from an irreducible polynomial. - - `modulus` may be of type :class:`~.fmpz_mod_poly` or :class:`~.nmod_poly`. - - `var` is a name for the ring generator of this field over the prime field. - - The optional parameter `type` select the implementation. For more - information about the types available, see :class:`~.fq_default_type` - for possible types. - """ - if check_prime and not (modulus).ctx.is_prime(): - raise ValueError("characteristic is not prime") - - if check_modulus and not modulus.is_irreducible(): - raise ValueError("modulus must be irreducible") - - fq_default_ctx_init_modulus_type(self.val, (modulus).val, - (modulus).ctx.mod.val, self.var.encode(), fq_type) - self._initialized = True - - @property - def fq_type(self): - """ - Return the implementation of this context - """ - return fq_default_type(fq_default_ctx_type(self.val)) - - def degree(self): - """ - The extension degree of the finite field - - >>> gf = fq_default_ctx(5, 2) - >>> gf.degree() - 2 - """ - return fq_default_ctx_degree(self.val) - - def characteristic(self): - """ - Return the characteristic of the finite field - - >>> gf = fq_default_ctx(5, 2) - >>> gf.characteristic() - 5 - """ - cdef fmpz p - p = fmpz.__new__(fmpz) - fq_default_ctx_prime(p.val, self.val) - return p - - prime = characteristic - - def order(self): - """ - Return the order of the finite field - - >>> gf = fq_default_ctx(5, 2) - >>> gf.order() - 25 - """ - cdef fmpz q - q = fmpz.__new__(fmpz) - fq_default_ctx_order(q.val, self.val) - return q - - def multiplicative_order(self): - """" - Return the multiplicative order of the finite field - - >>> gf = fq_default_ctx(5, 2) - >>> gf.multiplicative_order() - 24 - """ - return self.order() - 1 - - def modulus(self): - """ - Return the modulus from the context as an fmpz_mod_poly type - - >>> gf = fq_default_ctx(5, 2) - >>> gf.modulus() - x^2 + 4*x + 2 - """ - cdef fmpz_mod_poly_ctx ctx - cdef fmpz_mod_poly pol - ctx = fmpz_mod_poly_ctx(self.prime()) - pol = ctx.new_ctype_poly() - fq_default_ctx_modulus(pol.val, self.val) - return pol - - def zero(self): - """ - Return the zero element - - >>> gf = fq_default_ctx(5) - >>> gf.zero() - 0 - """ - cdef fq_default res - res = self.new_ctype_fq_default() - res.ctx = self - fq_default_zero(res.val, self.val) - return res - - def one(self): - """ - Return the unit element - - >>> gf = fq_default_ctx(5) - >>> gf.one() - 1 - """ - cdef fq_default res - res = self.new_ctype_fq_default() - res.ctx = self - fq_default_one(res.val, self.val) - return res - - def gen(self): - """ - Return the one element - - >>> gf = fq_default_ctx(5, 2, var="w") - >>> gf.gen() - w - """ - cdef fq_default res - res = self.new_ctype_fq_default() - res.ctx = self - fq_default_gen(res.val, self.val) - return res - - def random_element(self, not_zero=False): - r""" - Return a random element of the finite field - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf.random_element() - >>> type(a) is fq_default - True - >>> a = gf.random_element(not_zero=True) - >>> not a.is_zero() - True - """ - cdef fq_default res - res = self.new_ctype_fq_default() - res.ctx = self - if not_zero: - fq_default_rand_not_zero(res.val, global_random_state, self.val) - else: - fq_default_rand(res.val, global_random_state, self.val) - return res - - cdef new_ctype_fq_default(self): - return fq_default.__new__(fq_default, None, self) - - cdef set_list_as_fq_default(self, fq_default_t fq_ele, obj): - cdef fmpz_poly poly - poly = fmpz_poly.__new__(fmpz_poly) - fmpz_poly_set_list(poly.val, obj) - - # Now set the value from the fmpz_poly - fq_default_set_fmpz_poly(fq_ele, poly.val, self.val) - - return 0 - - cdef set_any_scalar_as_fq_default(self, fq_default_t fq_ele, obj): - cdef slong i - if typecheck(obj, int): - # For small integers we can convert directly - try: - i = obj - fq_default_set_si(fq_ele, i, self.val) - return 0 - # For larger integers fall through to conversion to fmpz - except OverflowError: - pass - - obj_fmpz = any_as_fmpz(obj) - fq_default_set_fmpz(fq_ele, (obj_fmpz).val, self.val) - return 0 - - # For fmpz we can also convert directly - if typecheck(obj, fmpz): - fq_default_set_fmpz(fq_ele, (obj).val, self.val) - return 0 - - # For nmod we can convert by taking it as an int - if typecheck(obj, nmod) and self.prime() == obj.modulus(): - fq_default_set_ui(fq_ele, (obj).val, self.val) - return 0 - - # For fmpz_mod we can also convert directly - if typecheck(obj, fmpz_mod) and self.prime() == (obj).ctx.modulus(): - fq_default_set_fmpz(fq_ele, (obj).val, self.val) - return 0 - - # Otherwise the object wasn't a scalar we convert from - return NotImplemented - - cdef set_any_as_fq_default(self, fq_default_t fq_ele, obj): - # First try and convert from scalars - check = self.set_any_scalar_as_fq_default(fq_ele, obj) - if check is not NotImplemented: - return 0 - - if typecheck(obj, fmpz_mod_poly) and self.prime() == (obj).ctx.mod.modulus(): - fq_default_set_fmpz_mod_poly(fq_ele, (obj).val, self.val) - return 0 - - if typecheck(obj, nmod_poly) and self.prime() == obj.modulus(): - fq_default_set_nmod_poly(fq_ele, (obj).val, self.val) - return 0 - - # If the input is not fmpz_mod_poly or nmod_poly or a list, we cast the - # input to an fmpz_poly and then set from this - poly = any_as_fmpz_poly(obj) - if poly is NotImplemented: - return NotImplemented - - fq_default_set_fmpz_poly(fq_ele, (poly).val, self.val) - return 0 - - cdef any_as_fq_default(self, obj): - # convert from fq_default - if typecheck(obj, fq_default): - if self != (obj).ctx: - raise ValueError("fields must match") - return obj - - cdef fq_default res - res = self.new_ctype_fq_default() - check = self.set_any_as_fq_default(res.val, obj) - if check is NotImplemented: - return NotImplemented - return res - - def __eq__(self, other): - """ - Two finite field context compare equal if they have same - characteristic, modulus, type and variable - - >>> from flint import fmpz_mod_poly_ctx - >>> modulus = fmpz_mod_poly_ctx(5)([2,4,1]) - >>> gf = fq_default_ctx(5, 2) - >>> gf2 = fq_default_ctx(modulus=modulus) - >>> gf2 == gf - True - >>> gf3 = fq_default_ctx(modulus=modulus, var="y") - >>> gf3 == gf - False - """ - cdef fq_default_ctx other_ctx - - if self is other: - return True - - if not typecheck(other, fq_default_ctx): - return NotImplemented - - other_ctx = other - - return (self.fq_type == other_ctx.fq_type - and self.var == other_ctx.var - and self.prime() == other_ctx.prime() - and self.modulus() == other_ctx.modulus()) - - def __hash__(self): - return hash((self.fq_type, self.var, self.prime(), self.modulus())) - - def __str__(self): - if self.degree() == 1: - return f"Context for fq_default in GF({self.prime()})" - return f"Context for fq_default in GF({self.prime()}^{self.degree()})[{self.var}]/({self.modulus().str(var=self.var)})" - - def __repr__(self): - if self.degree() == 1: - return f"fq_default_ctx({self.prime()}, var='{self.var}', type='{self.fq_type._name_}')" - return f"fq_default_ctx({self.prime()}, {self.degree()}, '{self.var}', {self.modulus()!r}, '{self.fq_type._name_}')" - - def __call__(self, val): - return fq_default(val, self) - - -cdef class fq_default(flint_scalar): - def __cinit__(self, val, ctx): - if not typecheck(ctx, fq_default_ctx): - raise TypeError - self.ctx = ctx - fq_default_init(self.val, self.ctx.val) - - def __dealloc__(self): - if self.ctx is not None: - fq_default_clear(self.val, self.ctx.val) - - def __init__(self, val, ctx): - if not typecheck(ctx, fq_default_ctx): - raise TypeError - self.ctx = ctx - - # Converts the list to an fmpz_poly and then sets from this - if typecheck(val, list): - self.ctx.set_list_as_fq_default(self.val, val) - return - - # Otherwise cascades through types to convert - check = self.ctx.set_any_as_fq_default(self.val, val) - if check is NotImplemented: - raise TypeError - - def __int__(self): - """ - Attempts to lift self to an integer of type fmpz in [0, p-1] - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> int(gf(123)) - 123 - """ - cdef fmpz x = fmpz.__new__(fmpz) - res = fq_default_get_fmpz(x.val, self.val, self.ctx.val) - if res == 1: - return int(x) - raise ValueError("fq element has no lift to the integers") - - def polynomial(self): - """ - Returns a representative of ``self`` as a polynomial in `(Z/pZ)[x] / h(x)` - where `h(x)` is the defining polynomial of the finite field. - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.polynomial() - 3*x^2 + 2*x + 1 - >>> gf(123).polynomial() - 123 - """ - cdef fmpz_mod_poly pol - - ring_ctx = fmpz_mod_poly_ctx(self.ctx.prime()) - pol = ring_ctx.new_ctype_poly() - fq_default_get_fmpz_mod_poly((pol).val, self.val, self.ctx.val) - - return pol - - def to_list(self): - """ - Returns self as a list of fmpz types corresponding to a - list of coefficients - - >>> gf = fq_default_ctx(163, 3) - >>> gf([-1,2,1]).to_list() - [162, 2, 1] - >>> gf.one().to_list() - [1, 0, 0] - """ - coeffs = [None for _ in range(self.ctx.degree())] - for i in range(self.ctx.degree()): - c = fmpz.__new__(fmpz) - fq_default_get_coeff_fmpz((c).val, self.val, i, self.ctx.val) - coeffs[i] = c - return coeffs - - def str(self): - return self.polynomial().str(var=self.ctx.var) - - def __hash__(self): - return hash((self.polynomial(), hash(self.ctx))) - - # ================================================= - # Comparisons - # ================================================= - def is_zero(self): - """ - Returns true is self is zero and false otherwise - - >>> gf = fq_default_ctx(163, 3) - >>> gf(0).is_zero() - True - >>> gf(-1).is_zero() - False - """ - return 1 == fq_default_is_zero(self.val, self.ctx.val) - - def is_one(self): - """ - Returns true is self is one and false otherwise - - >>> gf = fq_default_ctx(163, 3) - >>> gf(-1).is_one() - False - >>> gf(1).is_one() - True - """ - return 1 == fq_default_is_one(self.val, self.ctx.val) - - def __richcmp__(self, other, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("fq_default cannot be ordered") - - # If other is not an fq_default element, we attempt to convert to fq_default - if not typecheck(other, fq_default): - # For nmod and fmpz_mod if the modulus does not match the characteristic - # then we return false. - if typecheck(other, nmod) and self.ctx.characteristic() != (other).modulus(): - res = False - - elif typecheck(other, fmpz_mod) and self.ctx.characteristic() != (other).ctx.modulus(): - res = False - - else: - # Convert from int, fmpz, fmpz_mod and nmod to fq_default - cmp = self.ctx.new_ctype_fq_default() - check = self.ctx.set_any_scalar_as_fq_default((cmp).val, other) - - # Conversion failed, element was not a compatible scalar - if check is NotImplemented: - return NotImplemented - - # We now have an fq_default element with the same context, so compare value only - res = fq_default_equal(self.val, (cmp).val, self.ctx.val) - - # Flip the result of res if we're doing not equals - if op == 2: - return res - return not res - - # Otherwise we're in the case where other is also an fq_default but may have a - # different context. - - # If the contexts match exactly, only check values - if self.ctx == (other).ctx: - res = fq_default_equal(self.val, (other).val, self.ctx.val) - - # Otherwise if both contexts have the same characteristic check - # if both fq_default lift to the same integer - elif self.ctx.characteristic() == (other).ctx.characteristic(): - try: - res = int(self) == int(other) - # One or both lifts failed, so values are not equal - except ValueError: - res = False - - # Otherwise, values are considered not equal - else: - res = False - - # Flip the result of res if we're doing not equals - if op == 2: - return res - return not res - - # ================================================= - # Generic arithmetic required by flint_scalar - # ================================================= - - def _any_as_self(self, other): - return self.ctx.any_as_fq_default(other) - - cpdef fq_default _neg_(fq_default self): - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_neg(res.val, self.val, self.ctx.val) - return res - - cpdef fq_default _add_(fq_default self, fq_default other): - """ - Assumes that __add__() has ensured other is of type self - """ - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_add(res.val, self.val, other.val, self.ctx.val) - return res - - cpdef fq_default _sub_(fq_default self, fq_default other): - """ - Assumes that __sub__() has ensured other is of type self - """ - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_sub(res.val, self.val, other.val, res.ctx.val) - return res - - cpdef fq_default _rsub_(fq_default self, fq_default other): - """ - Assumes that __rsub__() has ensured other is of type self - """ - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_sub(res.val, other.val, self.val, res.ctx.val) - return res - - cpdef fq_default _mul_(fq_default self, fq_default other): - """ - Assumes that __mul__() has ensured other is of type self - - TODO: this could be optimised by using mul_si and others - """ - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_mul(res.val, self.val, other.val, self.ctx.val) - return res - - cpdef fq_default _div_(fq_default self, fq_default other): - """ - Assumes that __div__() has ensured other is of type self - """ - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_div(res.val, self.val, other.val, res.ctx.val) - return res - - cpdef fq_default _rdiv_(fq_default self, fq_default other): - """ - Assumes that __div__() has ensured other is of type self - """ - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_div(res.val, other.val, self.val, res.ctx.val) - return res - - cpdef fq_default _invert_(fq_default self): - cdef fq_default res = self.ctx.new_ctype_fq_default() - fq_default_inv(res.val, self.val, self.ctx.val) - return res - - # ================================================= - # Additional arithmetic - # ================================================= - - def inverse(self): - """ - Computes the inverse of self - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> b = a.inverse() - >>> b - 68*z^2 + 17*z + 116 - >>> a*b == gf.one() - True - """ - return self._invert_() - - def square(self): - """ - Computes the square of ``self`` - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.square() == a*a - True - >>> a.square() - 110*z^2 + 101*z + 25 - """ - cdef fq_default res - res = self.ctx.new_ctype_fq_default() - fq_default_sqr(res.val, self.val, self.ctx.val) - return res - - def __pow__(self, e): - """ - Compute `a^e` for `a` equal to ``self``. - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> pow(a, -1) == 1/a - True - >>> pow(a, 2) == a * a - True - >>> pow(a, 2**128) == pow(a, 2**128 % (163**3 - 1)) - True - >>> pow(a, 123) - 46*z^2 + 110*z + 155 - - """ - cdef fq_default res - res = self.ctx.new_ctype_fq_default() - - # If e is negative, we invert first - if e < 0: - if self.is_zero(): - raise ZeroDivisionError - e = -e - fq_default_inv(res.val, self.val, self.ctx.val) - else: - fq_default_set(res.val, self.val, self.ctx.val) - - # For small e we dont need to make an fmpz - if e.bit_length() < 32: - fq_default_pow_ui(res.val, res.val, e, self.ctx.val) - return res - - # Cast the exponent to fmpz type - e_fmpz = any_as_fmpz(e) - fq_default_pow(res.val, res.val, (e_fmpz).val, self.ctx.val) - - return res - - def sqrt(self): - """ - Returns the square root of the element, if not square root exists, - throws a ValueError. - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([3,2,1]) - >>> a.is_square() - True - >>> b = a.sqrt() - >>> b - 95*z^2 + 36*z + 34 - >>> b**2 in [a, -a] - True - """ - cdef fq_default res - res = self.ctx.new_ctype_fq_default() - check = fq_default_sqrt(res.val, self.val, self.ctx.val) - if check: - return res - raise DomainError("element is not a square") - - def is_square(self): - """ - Returns if the element is a square in the field - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.is_square() - False - >>> (a*a).is_square() - True - """ - return 1 == fq_default_is_square(self.val, self.ctx.val) - - def pth_root(self): - """ - Returns the pth root of the element. - - This is computed by raising ``self`` to the `p^(d-1)` power, - `p` is the characteristic of the field and `d` is the degree - of the extension. - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.pth_root() - 5*z^2 + 152*z + 119 - """ - cdef fq_default res - res = self.ctx.new_ctype_fq_default() - fq_default_pth_root(res.val, self.val, self.ctx.val) - return res - - # ================================================= - # Special functions - # ================================================= - - def trace(self): - """ - Returns the trace of self - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.trace() - 124 - """ - cdef fmpz tr = fmpz.__new__(fmpz) - fq_default_trace(tr.val, self.val, self.ctx.val) - return tr - - def norm(self): - """ - Returns the norm of self - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.norm() - 116 - """ - cdef fmpz nrm = fmpz.__new__(fmpz) - fq_default_norm(nrm.val, self.val, self.ctx.val) - return nrm - - def frobenius(self, e=1): - r""" - Evaluates the homomorphism `\Sigma^e` on ``self``. - - >>> gf = fq_default_ctx(163, 3) - >>> a = gf([1,2,3]) - >>> a.frobenius() - 155*z^2 + 9*z + 4 - >>> a.frobenius(2) - 5*z^2 + 152*z + 119 - >>> a == a.frobenius(3) - True - >>> a.frobenius(2) == a.frobenius(-1) - True - """ - cdef fq_default res - res = self.ctx.new_ctype_fq_default() - fq_default_frobenius(res.val, self.val, e, self.ctx.val) - return res diff --git a/src/flint/types/fq_default_poly.pxd b/src/flint/types/fq_default_poly.pxd deleted file mode 100644 index e3a76f1f..00000000 --- a/src/flint/types/fq_default_poly.pxd +++ /dev/null @@ -1,23 +0,0 @@ -from flint.flintlib.functions.fq_default_poly cimport * -from flint.flintlib.functions.fq_default_poly_factor cimport * -from flint.flintlib.functions.fq_default cimport ( - fq_default_neg, - fq_default_get_coeff_fmpz, -) - -from flint.flint_base.flint_base cimport flint_poly -from flint.types.fq_default cimport fq_default_ctx - - -cdef class fq_default_poly_ctx: - cdef fq_default_ctx field - cdef any_as_fq_default_poly(self, obj) - cdef set_any_as_fq_default_poly(self, fq_default_poly_t poly, obj) - cdef set_list_as_fq_default_poly(self, fq_default_poly_t poly, val) - cdef new_ctype_poly(self) - -cdef class fq_default_poly(flint_poly): - cdef fq_default_poly_t val - cdef fq_default_poly_ctx ctx - cpdef long length(self) - cpdef long degree(self) diff --git a/src/flint/types/fq_default_poly.pyi b/src/flint/types/fq_default_poly.pyi deleted file mode 100644 index 855143a0..00000000 --- a/src/flint/types/fq_default_poly.pyi +++ /dev/null @@ -1,143 +0,0 @@ -from typing import overload, Sequence -from flint.flint_base.flint_base import flint_poly -from .fmpz import fmpz, ifmpz -from .fmpz_mod import fmpz_mod -from .fmpz_poly import fmpz_poly, ifmpz_poly -from .fmpz_mod_poly import fmpz_mod_poly -from .fq_default import fq_default_type, fq_default_ctx, fq_default, ifq_default - -ifmpz_mod = int | fmpz | fmpz_mod -ifq_default_poly = fq_default_poly | ifq_default | ifmpz_poly - -class fq_default_poly_ctx: - r"""Context object for creating :class:`~.fq_default_poly` initialised - with a finite field `GF(p^d)`. - """ - - @overload - def __init__(self, p: fq_default_ctx, /) -> None: ... - @overload - def __init__( - self, - p: fq_default_ctx | ifmpz | None = None, - degree: int | None = None, - var: str | None = None, - modulus: fmpz_mod_poly | fmpz_poly | None = None, - fq_type: str | int | fq_default_type = fq_default_type.DEFAULT, - check_prime: bool = True, - check_modulus: bool = True, - ): ... - def base_field(self) -> fq_default_ctx: ... - def characteristic(self) -> fmpz: ... - def prime(self) -> fmpz: ... - def zero(self) -> fq_default_poly: ... - def one(self) -> fq_default_poly: ... - def gen(self) -> fq_default_poly: ... - def random_element( - self, - degree: int = 3, - not_zero: bool = False, - monic: bool = False, - irreducible: bool = False, - ) -> fq_default_poly: ... - def __str__(self) -> str: ... - def __repr__(self) -> str: ... - def __call__(self, val: ifq_default_poly) -> fq_default_poly: ... - -class fq_default_poly(flint_poly[fq_default]): - """ - The *fq_default_poly* type represents univariate polynomials - over a finite field. - """ - - def __init__( - self, - other: Sequence[ifq_default] | ifq_default_poly, - ctx: fq_default_poly_ctx, - /, - ) -> None: ... - def context(self) -> fq_default_poly_ctx: ... - def __getitem__(self, i: int, /) -> fq_default: ... - def __setitem__(self, i: int, x: ifq_default, /) -> None: ... - def __len__(self) -> int: ... - def length(self) -> int: ... - def degree(self) -> int: ... - def constant_coefficient(self) -> fq_default: ... - def leading_coefficient(self) -> fq_default: ... - def reverse(self, degree: int | None = None) -> fq_default_poly: ... - def truncate(self, n: int) -> fq_default_poly: ... - def monic(self) -> fq_default_poly: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_gen(self) -> bool: ... - def is_constant(self) -> bool: ... - def is_monic(self) -> bool: ... - def is_irreducible(self) -> bool: ... - def is_squarefree(self) -> bool: ... - def __pos__(self) -> fq_default_poly: ... - def __neg__(self) -> fq_default_poly: ... - def __add__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __radd__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __sub__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __rsub__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __mul__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __rmul__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __floordiv__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __rfloordiv__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __mod__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __rmod__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __divmod__( - self, other: ifq_default_poly, / - ) -> tuple[fq_default_poly, fq_default_poly]: ... - def __rdivmod__( - self, other: ifq_default_poly, / - ) -> tuple[fq_default_poly, fq_default_poly]: ... - def __truediv__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __rtruediv__(self, other: ifq_default_poly, /) -> fq_default_poly: ... - def __pow__( - self, e: int, mod: ifq_default_poly | None = None - ) -> fq_default_poly: ... - def pow_mod(self, e: int, modulus: ifq_default_poly) -> fq_default_poly: ... - def divmod( - self, other: ifq_default_poly - ) -> tuple[fq_default_poly, fq_default_poly]: ... - def exact_division(self, other: ifq_default_poly) -> fq_default_poly: ... - def gcd(self, other: ifq_default_poly) -> fq_default_poly: ... - def xgcd( - self, other: ifq_default_poly, / - ) -> tuple[fq_default_poly, fq_default_poly, fq_default_poly]: ... - def square(self) -> fq_default_poly: ... - def left_shift(self, n: int) -> fq_default_poly: ... - def right_shift(self, n: int) -> fq_default_poly: ... - def sqrt(self) -> fq_default_poly: ... - def mul_mod( - self, other: ifq_default_poly, modulus: ifq_default_poly - ) -> fq_default_poly: ... - def equal_trunc(self, other: ifq_default_poly, n: int) -> bool: ... - def add_trunc(self, other: ifq_default_poly, n: int) -> fq_default_poly: ... - def sub_trunc(self, other: ifq_default_poly, n: int) -> fq_default_poly: ... - def mul_low(self, other: ifq_default_poly, n: int) -> fq_default_poly: ... - def pow_trunc(self, e: int, n: int) -> fq_default_poly: ... - def sqrt_trunc(self, n: int) -> fq_default_poly: ... - def inv_sqrt_trunc(self, n: int) -> fq_default_poly: ... - def inverse_series_trunc(self, n: int) -> fq_default_poly: ... - def inverse_mod(self, other: ifq_default_poly) -> fq_default_poly: ... - def derivative(self) -> fq_default_poly: ... - def radical(self) -> fq_default_poly: ... - def inflate(self, n: int) -> fq_default_poly: ... - def deflate(self, n: int) -> fq_default_poly: ... - def deflation(self) -> tuple[fq_default_poly, int]: ... - @overload - def __call__(self, input: ifq_default) -> fq_default: ... - @overload - def __call__(self, input: fq_default_poly) -> fq_default_poly: ... - def evaluate(self, input: ifq_default) -> fq_default_poly: ... - def compose(self, other: ifq_default_poly) -> fq_default_poly: ... - def compose_mod( - self, other: ifq_default_poly, modulus: ifq_default_poly - ) -> fq_default_poly: ... - def factor_squarefree( - self, - ) -> tuple[fq_default, list[tuple[fq_default_poly, int]]]: ... - def factor(self) -> tuple[fq_default, list[tuple[fq_default_poly, int]]]: ... - def roots(self, multiplicities=True) -> list[tuple[fq_default, int]]: ... diff --git a/src/flint/types/fq_default_poly.pyx b/src/flint/types/fq_default_poly.pyx deleted file mode 100644 index 8972a4d7..00000000 --- a/src/flint/types/fq_default_poly.pyx +++ /dev/null @@ -1,1751 +0,0 @@ -cimport cython -from cpython.list cimport PyList_Size as PyList_GET_SIZE -from flint.flint_base.flint_base cimport flint_poly - -from flint.types.fmpz cimport fmpz, any_as_fmpz -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.fmpz_mod_poly cimport fmpz_mod_poly -from flint.types.nmod_poly cimport nmod_poly -from flint.types.fq_default cimport fq_default_ctx, fq_default - -from flint.pyflint cimport global_random_state - -from flint.utils.typecheck cimport typecheck - -from flint.utils.flint_exceptions import DomainError - -cdef class fq_default_poly_ctx: - r""" - Context object for creating :class:`~.fq_default_poly` initialised - with a finite field `GF(p^d)`. - - >>> fq_default_poly_ctx(163, 3, fq_type="FQ_NMOD") - fq_default_poly_ctx(fq_default_ctx(163, 3, 'z', x^3 + 7*x + 161, 'FQ_NMOD')) - """ - def __cinit__(self): - pass - - def __dealloc__(self): - pass - - def __init__(self, *args, **kwargs): - # Allow context to be made from fq_default_ctx - if len(args) == 1 and typecheck(args[0], fq_default_ctx): - self.field = args[0] - else: # Otherwise attempt to create context from moduli - self.field = fq_default_ctx(*args, **kwargs) - - cdef set_list_as_fq_default_poly(self, fq_default_poly_t poly, val): - cdef long i, n - - # Get size of list and create a polynomial of length n - n = PyList_GET_SIZE(val) - fq_default_poly_fit_length(poly, n, self.field.val) - - # Iterate through the list and attempt to coerce every element - # to an fq_type using the context - for i in range(n): - # First coerce the list element as an fq_default type - v = self.field.any_as_fq_default(val[i]) - if v is NotImplemented: - raise TypeError(f"unsupported coefficient in list: val[i] = {val[i]}, type(val[i] = {type(val[i])}") - - # Set the coefficient of the polynomial - fq_default_poly_set_coeff( - poly, i, (v).val, self.field.val - ) - - cdef set_any_as_fq_default_poly(self, fq_default_poly_t poly, obj): - # First try and coerce polynomials to polynomials - if typecheck(obj, fq_default_poly): - if self != (obj).ctx: - raise ValueError("fields must match") - fq_default_poly_set(poly, (obj).val, self.field.val) - return - - if typecheck(obj, fmpz_poly): - fq_default_poly_set_fmpz_poly(poly, (obj).val, self.field.val) - return - - if typecheck(obj, fmpz_mod_poly) and self.prime() == (obj).ctx.modulus(): - fq_default_poly_set_fmpz_mod_poly(poly, (obj).val, self.field.val) - return - - if typecheck(obj, nmod_poly) and self.prime() == (obj).modulus(): - fq_default_poly_set_nmod_poly(poly, (obj).val, self.field.val) - return - - # Otherwise attempt to coerce the object to fq_default and - # set a constant polynomial - v = self.field.any_as_fq_default(obj) - if v is NotImplemented: - return NotImplemented - - fq_default_poly_set_fq_default(poly, (v).val, self.field.val) - - cdef any_as_fq_default_poly(self, obj): - # If fq_default_poly, return if fields match - if typecheck(obj, fq_default_poly): - if self != (obj).ctx: - raise ValueError("fields must match") - return obj - - # For all other types attempt to coerce to a fq_default_poly - cdef fq_default_poly res - res = self.new_ctype_poly() - check = self.set_any_as_fq_default_poly(res.val, obj) - if check is NotImplemented: - return NotImplemented - return res - - def base_field(self): - """ - Return the base field of the polynomial ring - - >>> R = fq_default_poly_ctx(65537, 3) - >>> R.base_field() # doctest: +SKIP - fq_default_ctx(65537, 3, 'z', x^3 + 3*x^2 + 30077, 'FQ_NMOD') - - """ - return self.field - - def characteristic(self): - """ - Return the characteristic of the field from the context - as an ``fmpz`` type - - >>> R = fq_default_poly_ctx(65537, 3) - >>> R.characteristic() - 65537 - - """ - return self.field.characteristic() - - prime = characteristic - - def zero(self): - """ - Return the zero element of this polynomial ring - - >>> R = fq_default_poly_ctx(163) - >>> R.zero() - 0 - """ - cdef fq_default_poly res - res = self.new_ctype_poly() - fq_default_poly_zero(res.val, self.field.val) - return res - - def one(self): - """ - Return the one element of this polynomial ring - - >>> R = fq_default_poly_ctx(163) - >>> R.one() - 1 - """ - cdef fq_default_poly res - res = self.new_ctype_poly() - fq_default_poly_one(res.val, self.field.val) - return res - - def gen(self): - """ - Return the generator of the polynomial: `x` - - >>> R = fq_default_poly_ctx(163) - >>> R.gen() - x - """ - cdef fq_default_poly res - res = self.new_ctype_poly() - fq_default_poly_gen(res.val, self.field.val) - return res - - def random_element(self, degree=3, not_zero=False, monic=False, irreducible=False): - """ - Return a random element of degree ``degree``. If ``not_zero`` - is ``True``, ensures the output is not zero, if ``monic`` is - ``True``, ensures the output is monic. If ``irreducible`` is - ``True``, ensures that the output is irreducible. - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R.random_element() - >>> f.degree() <= 3 - True - >>> f = R.random_element(degree=123) - >>> f.degree() <= 123 - True - >>> f = R.random_element(monic=True) - >>> f.is_monic() - True - >>> f = R.random_element(degree=13, monic=True, irreducible=True) - >>> f.degree() <= 13 - True - >>> f.is_monic() - True - >>> f.is_irreducible() - True - """ - cdef slong length - if not (isinstance(monic, bool) and isinstance(irreducible, bool) and isinstance(not_zero, bool)): - raise TypeError("All of 'not_zero', 'monic' and 'irreducible' must be of type bool") - - length = degree + 1 - if length <= 0: - raise ValueError("The degree argument must be non-negative") - - cdef fq_default_poly res - res = self.new_ctype_poly() - # all irreducible elements are returned as monic polynomials - if irreducible: - fq_default_poly_randtest_irreducible( - res.val, global_random_state, length, self.field.val - ) - elif monic: - fq_default_poly_randtest_monic( - res.val, global_random_state, length, self.field.val - ) - elif not_zero: - fq_default_poly_randtest_not_zero( - res.val, global_random_state, length, self.field.val - ) - else: - fq_default_poly_randtest( - res.val, global_random_state, length, self.field.val - ) - return res - - cdef new_ctype_poly(self): - return fq_default_poly.__new__(fq_default_poly, None, self) - - def __eq__(self, other): - # Most often, we expect both `fq_default_poly` to be pointing - # to the same ctx, so this seems the fastest way to check - if self is other: - return True - - # If they're not the same object in memory, they may have the - # same field, which is good enough - if typecheck(other, fq_default_poly_ctx): - return self.field == (other).field - return False - - def __hash__(self): - return hash(("polynomial_ring", self.field)) - - def __str__(self): - return f"Context for fq_default_poly with field: {self.field}" - - def __repr__(self): - return f"fq_default_poly_ctx({repr(self.field)})" - - def __call__(self, val): - return fq_default_poly(val, self) - - -@cython.final -@cython.no_gc -cdef class _fq_default_poly_sort_key: - cdef fq_default_poly p - cdef ulong mult - cdef slong len - - def __init__(self, tuple fac_m): - self.p = fac_m[0] - self.len = fq_default_poly_length(self.p.val, self.p.ctx.field.val) - self.mult = fac_m[1] - - def __lt__(k1, _fq_default_poly_sort_key k2): - cdef slong i, j, d - cdef fq_default c1, c2 - cdef fmpz z1, z2 - cdef fq_default_ctx field - - if k1.len != k2.len: - return k1.len < k2.len - elif k1.mult != k2.mult: - return k1.mult < k2.mult - - field = k1.p.ctx.field - d = field.degree() - z1 = fmpz() - z2 = fmpz() - c1 = field.zero() - c2 = field.zero() - - i = k1.len - while i >= 0: - i -= 1 - fq_default_poly_get_coeff(c1.val, k1.p.val, i, field.val) - fq_default_poly_get_coeff(c2.val, k2.p.val, i, field.val) - if c1 != c2: - j = d - while j > 0: - j -= 1 - fq_default_get_coeff_fmpz(z1.val, c1.val, j, field.val) - fq_default_get_coeff_fmpz(z2.val, c2.val, j, field.val) - if z1 != z2: - return z1 < z2 - else: - raise RuntimeError("Bad cmp in _fq_default_poly_sort_key!") - else: - return False - - -cdef class fq_default_poly(flint_poly): - """ - The *fq_default_poly* type represents univariate polynomials - over a finite field. - - An *fq_default_poly* element is constructed from an :class:`~.fq_default_poly_ctx` - either by passing it as an argument to the type, or - by directly calling the context: - - >>> fq_default_poly([1,-2,3], fq_default_poly_ctx(2**127 - 1)) - 3*x^2 + 170141183460469231731687303715884105725*x + 1 - >>> R = fq_default_poly_ctx(2**127 - 1) - >>> R([4,5,6]) - 6*x^2 + 5*x + 4 - - """ - def __cinit__(self, val, ctx): - if not typecheck(ctx, fq_default_poly_ctx): - raise TypeError - self.ctx = ctx - fq_default_poly_init(self.val, self.ctx.field.val) - - def __dealloc__(self): - if self.ctx is not None: - fq_default_poly_clear(self.val, self.ctx.field.val) - - def __init__(self, val, ctx): - if typecheck(val, list): - self.ctx.set_list_as_fq_default_poly(self.val, val) - return - - check = self.ctx.set_any_as_fq_default_poly(self.val, val) - if check is NotImplemented: - raise TypeError - - def context(self): - return self.ctx - - def repr(self): - coeffs_str = ", ".join(map(str, self.coeffs())) - return f"fq_default_poly([{coeffs_str}], {self.ctx!r})" - - def __getitem__(self, long i): - cdef fq_default x - x = self.ctx.field.new_ctype_fq_default() - if i < 0: - return x - fq_default_poly_get_coeff( - x.val, self.val, i, self.ctx.field.val - ) - return x - - def __setitem__(self, long i, x): - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - v = self.ctx.field.any_as_fq_default(x) - if v is NotImplemented: - raise TypeError - fq_default_poly_set_coeff( - self.val, i, (v).val, self.ctx.field.val - ) - - def __richcmp__(self, other, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("fq_default_poly cannot be ordered") - - if not typecheck(other, fq_default_poly): - other = self.ctx.any_as_fq_default_poly(other) - - if typecheck(other, fq_default_poly): - res = (self.ctx == (other).ctx) and \ - fq_default_poly_equal(self.val, (other).val, self.ctx.field.val) - if op == 2: - return res - else: - return not res - else: - return NotImplemented - - def __len__(self): - return self.length() - - def __hash__(self): - return hash(tuple(self.coeffs())) - - cpdef long length(self): - """ - Return the length of the polynomial - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.length() - 3 - - """ - return fq_default_poly_length(self.val, self.ctx.field.val) - - cpdef long degree(self): - """ - Return the degree of the polynomial - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.degree() - 2 - - """ - return fq_default_poly_degree(self.val, self.ctx.field.val) - - def constant_coefficient(self): - """ - Return the constant coefficient of this polynomial. - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R([1,2,3]) - >>> f.constant_coefficient() - 1 - """ - return self[0] - - def leading_coefficient(self): - """ - Return the leading coefficient of this polynomial. - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.leading_coefficient() - 3 - """ - d = self.degree() - if d < 0: - return self.ctx.field.zero() - return self[self.degree()] - - def reverse(self, degree=None): - """ - Return a polynomial with the coefficients of this polynomial - reversed. - - If ``degree`` is not None, the output polynomial will be zero-padded - or truncated before being reversed. NOTE: degree must be non-negative. - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R([1,2,3,4,5]) - >>> f.reverse() - x^4 + 2*x^3 + 3*x^2 + 4*x + 5 - >>> f.reverse(degree=1) - x + 2 - >>> f.reverse(degree=100) - x^100 + 2*x^99 + 3*x^98 + 4*x^97 + 5*x^96 - """ - cdef fq_default_poly res - cdef slong d - - if degree is not None: - d = degree - if d != degree or d < 0: - raise ValueError(f"degree argument must be a non-negative integer, got {degree}") - else: - d = fq_default_poly_degree(self.val, self.ctx.field.val) - - length = d + 1 - - res = self.ctx.new_ctype_poly() - fq_default_poly_reverse(res.val, self.val, length, self.ctx.field.val) - return res - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> R = fq_default_poly_ctx(163, 5) - >>> f = R([1,2,3]) - >>> f.truncate(3) == f - True - >>> f.truncate(2) - 2*x + 1 - >>> f.truncate(1) - 1 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - """ - cdef fq_default_poly res - - length = fq_default_poly_degree(self.val, self.ctx.field.val) - res = self.ctx.new_ctype_poly() - - if n <= 0: # return zero - return res - elif n > length: # do nothing - fq_default_poly_set( - res.val, self.val, self.ctx.field.val - ) - else: - fq_default_poly_set_trunc( - res.val, self.val, n, self.ctx.field.val - ) - return res - - def monic(self): - """ - Return this polynomial divided by its leading coefficient. - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.monic() - x^2 + 55*x + 109 - """ - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_make_monic( - res.val, self.val, self.ctx.field.val - ) - return res - - def is_zero(self): - """ - Return ``True`` if the polynomial is the zero polynomial - and ``False`` otherwise - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R.zero() - >>> f.is_zero() - True - """ - return 0 != fq_default_poly_is_zero(self.val, self.ctx.field.val) - - def is_one(self): - """ - Return ``True`` if the polynomial is equal to one - and ``False`` otherwise - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R.one() - >>> f.is_one() - True - """ - return 0 != fq_default_poly_is_one(self.val, self.ctx.field.val) - - def is_gen(self): - """ - Return ``True`` if the polynomial is the generator - of the polynomial, `x`, and ``False`` otherwise - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R([0,1]) - >>> f.is_gen() - True - """ - return 0 != fq_default_poly_is_gen(self.val, self.ctx.field.val) - - def is_constant(self): - """ - Return ``True`` if this is a constant polynomial. - - >>> R = fq_default_poly_ctx(163, 3) - >>> x = R.gen() - >>> x.is_constant() - False - >>> R(123).is_constant() - True - """ - return self.degree() <= 0 - - def is_monic(self): - """ - Return whether this polynomial is monic. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = x**2 + 5*x + 3 - >>> f.is_monic() - True - >>> f = 5*x**2 + x + 3 - >>> f.is_monic() - False - """ - return self.leading_coefficient().is_one() - - def is_irreducible(self): - """ - Return whether this polynomial is irreducible. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = x**2 + 5*x + 3 - >>> f.is_irreducible() - True - >>> f = x**2 + x + 3 - >>> f.is_irreducible() - False - """ - return 1 == fq_default_poly_is_irreducible(self.val, self.ctx.field.val) - - def is_squarefree(self): - """ - Return whether this polynomial is squarefree. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = (x + 1)**2 * (x + 3) - >>> f.is_squarefree() - False - >>> f = (x + 1) * (x + 3) - >>> f.is_squarefree() - True - - """ - return 1 == fq_default_poly_is_squarefree(self.val, self.ctx.field.val) - - # ==================================== - # Native Arithmetic - # ==================================== - - def __pos__(self): - return self - - def __neg__(self): - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_neg( - res.val, self.val, self.ctx.field.val - ) - return res - - def __add__(self, other): - cdef fq_default_poly res - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return NotImplemented - - res = self.ctx.new_ctype_poly() - fq_default_poly_add( - res.val, self.val, (other).val, self.ctx.field.val - ) - return res - - def __radd__(self, other): - return self.__add__(other) - - def __sub__(self, other): - cdef fq_default_poly res - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return NotImplemented - - res = self.ctx.new_ctype_poly() - fq_default_poly_sub( - res.val, self.val, (other).val, self.ctx.field.val - ) - return res - - def __rsub__(self, other): - cdef fq_default_poly res - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return NotImplemented - - res = self.ctx.new_ctype_poly() - fq_default_poly_sub( - res.val, (other).val, self.val, self.ctx.field.val - ) - return res - - def __mul__(self, other): - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - - # First try scalar multiplication - if not typecheck(other, fq_default_poly): - scalar = self.ctx.field.any_as_fq_default(other) - if scalar is not NotImplemented: - fq_default_poly_scalar_mul_fq_default( - res.val, self.val, (scalar).val, self.ctx.field.val - ) - return res - - # Otherwise treat other as an fq_default_poly - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return NotImplemented - fq_default_poly_mul( - res.val, self.val, (other).val, self.ctx.field.val - ) - return res - - def __rmul__(self, other): - return self.__mul__(other) - - def __pow__(self, e, mod=None): - if mod is not None: - return self.pow_mod(e, mod) - - cdef fq_default_poly res - if e < 0: - self = 1 / self - e = -e - - if e == 2: - return self.square() - - res = self.ctx.new_ctype_poly() - fq_default_poly_pow( - res.val, self.val, e, self.ctx.field.val - ) - return res - - def pow_mod(self, e, modulus): - r""" - Returns ``self`` raised to the power ``e`` modulo ``modulus``: - :math:`f^e \mod g`/ - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> mod = x**4 + 93*x**3 + 78*x**2 + 72*x + 149 - >>> f.pow_mod(123, mod) - 3*x^3 + 25*x^2 + 115*x + 161 - >>> f.pow_mod(2**64, mod) - 52*x^3 + 96*x^2 + 136*x + 9 - """ - cdef fq_default_poly res - - if e < 0: - raise ValueError("Exponent must be non-negative") - - modulus = self.ctx.any_as_fq_default_poly(modulus) - if modulus is NotImplemented: - raise TypeError(f"Cannot interpret {modulus} as a polynomial") - - # Output polynomial - res = self.ctx.new_ctype_poly() - - # For small exponents, use a simple binary exponentiation method - if e.bit_length() < 32: - fq_default_poly_powmod_ui_binexp( - res.val, self.val, e, (modulus).val, res.ctx.field.val - ) - return res - - # For larger exponents we need to cast e to an fmpz first - e_fmpz = any_as_fmpz(e) - fq_default_poly_powmod_fmpz_binexp( - res.val, self.val, (e_fmpz).val, (modulus).val, res.ctx.field.val - ) - return res - - def divmod(self, other): - """ - Return `Q`, `R` such that for ``self`` = `F` and ``other`` = `G`, - `F = Q*G + R` - - >>> R = fq_default_poly_ctx(163) - >>> f = R([123, 129, 63, 14, 51, 76, 133]) - >>> g = R([106, 134, 32, 41, 158, 115, 115]) - >>> f.divmod(g) - (21, 106*x^5 + 156*x^4 + 131*x^3 + 43*x^2 + 86*x + 16) - """ - cdef fq_default_poly Q, R - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - if other.is_zero(): - raise ZeroDivisionError(f"Cannot compute divmod as {other =}") - - Q = self.ctx.new_ctype_poly() - R = self.ctx.new_ctype_poly() - fq_default_poly_divrem( - Q.val, R.val, self.val, (other).val, self.ctx.field.val - ) - return Q, R - - def __divmod__(self, other): - return self.divmod(other) - - def __rdivmod__(self, other): - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return other - return other.divmod(self) - - def exact_division(self, other): - """ - Attempt to compute the exact quotient of self with other. - - Raises a value error if division without remainder is not - possible. - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,1]) - >>> g = R([1,1]) - >>> f.exact_division(g) - x + 1 - """ - cdef bint check - cdef fq_default_poly res - - # Case when right is not fq_default_poly, try to convert to fmpz - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot convert {other} to 'fq_default_poly' type.") - - if other.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - - res = self.ctx.new_ctype_poly() - check = fq_default_poly_divides( - res.val, self.val, (other).val, res.ctx.field.val - ) - if check == 0: - raise DomainError( - f"{other} does not divide {self}" - ) - - return res - - def __truediv__(self, other): - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - - # First try scalar division - if not typecheck(other, fq_default_poly): - scalar = self.ctx.field.any_as_fq_default(other) - if scalar is not NotImplemented: - if scalar.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - fq_default_poly_scalar_div_fq_default( - res.val, self.val, (scalar).val, self.ctx.field.val - ) - return res - - # Otherwise treat other as an fq_default_poly - return self.exact_division(other) - - def __rtruediv__(self, other): - if self.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return other - return other.exact_division(self) - - def __floordiv__(self, other): - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - - # First try scalar division - if not typecheck(other, fq_default_poly): - scalar = self.ctx.field.any_as_fq_default(other) - if scalar is not NotImplemented: - if scalar.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - fq_default_poly_scalar_div_fq_default( - res.val, self.val, (scalar).val, self.ctx.field.val - ) - return res - - # Coerce right element to fq_default_poly - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return other - - # Do not divide by zero - if other.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - - # floor division uses divmod but ignores the rem term - cdef fq_default_poly rem - rem = self.ctx.new_ctype_poly() - - fq_default_poly_divrem( - res.val, rem.val, self.val, (other).val, self.ctx.field.val - ) - return res - - def __rfloordiv__(self, other): - cdef fq_default_poly res - cdef fq_default_poly rem - - # Do not divide by zero - if self.is_zero(): - raise ZeroDivisionError("Cannot divide by zero") - - # Coerce right element to fq_default_poly - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return other - - # floor division uses divmod but ignores the rem term - res = self.ctx.new_ctype_poly() - rem = self.ctx.new_ctype_poly() - fq_default_poly_divrem( - res.val, rem.val, (other).val, self.val, self.ctx.field.val - ) - return res - - def __mod__(self, other): - cdef fq_default_poly res - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return NotImplemented - - if other.is_zero(): - raise ZeroDivisionError("Cannot compute remainder modulo 0") - - res = self.ctx.new_ctype_poly() - fq_default_poly_rem( - res.val, self.val, (other).val, self.ctx.field.val - ) - return res - - def __rmod__(self, other): - cdef fq_default_poly res - - if self.is_zero(): - raise ZeroDivisionError("Cannot compute remainder modulo 0") - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - return NotImplemented - - res = self.ctx.new_ctype_poly() - fq_default_poly_rem( - res.val, (other).val, self.val, self.ctx.field.val - ) - return res - - # ==================================== - # Additional Arithmetic - # ==================================== - - def square(self): - """ - Returns the square of ``self`` - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3]) - >>> f.square() - 9*x^4 + 12*x^3 + 10*x^2 + 4*x + 1 - """ - cdef fq_default_poly res - - res = self.ctx.new_ctype_poly() - fq_default_poly_sqr( - res.val, self.val, self.ctx.field.val - ) - return res - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> R = fq_default_poly_ctx(163) - >>> f = R([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 - - """ - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - - if n > 0: - fq_default_poly_shift_left( - res.val, self.val, n, self.ctx.field.val - ) - else: # do nothing, just copy self - fq_default_poly_set( - res.val, self.val, self.ctx.field.val - ) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> R = fq_default_poly_ctx(163) - >>> f = R([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 - """ - cdef fq_default_poly res - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - - res = self.ctx.new_ctype_poly() - - if n > 0: - fq_default_poly_shift_right( - res.val, self.val, n, self.ctx.field.val - ) - else: # do nothing, just copy self - fq_default_poly_set( - res.val, self.val, self.ctx.field.val - ) - - return res - - def sqrt(self): - """ - If ``self`` is a perfect square, compute the square root - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,1]) - >>> (f*f).sqrt() - x + 1 - - """ - cdef fq_default_poly res - cdef int check - - res = self.ctx.new_ctype_poly() - check = fq_default_poly_sqrt( - res.val, self.val, res.ctx.field.val - ) - if check != 1: - raise DomainError( - f"Cannot compute square-root {self}" - ) - return res - - def mul_mod(self, other, modulus): - """ - Computes the multiplication of ``self`` with ``other`` - modulo the polynomial ``modulus`` - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> g = 43*x**6 + 91*x**5 + 77*x**4 + 113*x**3 + 71*x**2 + 132*x + 60 - >>> mod = x**4 + 93*x**3 + 78*x**2 + 72*x + 149 - >>> - >>> f.mul_mod(g, mod) - 106*x^3 + 44*x^2 + 53*x + 77 - """ - cdef fq_default_poly res - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - modulus = self.ctx.any_as_fq_default_poly(modulus) - if modulus is NotImplemented: - raise TypeError(f"Cannot interpret {modulus} as a polynomial") - - res = self.ctx.new_ctype_poly() - - fq_default_poly_mulmod( - res.val, self.val, (other).val, (modulus).val, res.ctx.field.val - ) - return res - - # ==================================== - # Truncated Arithmetic - # ==================================== - - def equal_trunc(self, other, slong n): - """ - Returns if two polynomials are equal when truncated to the first ``n`` terms - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> h = R([1,2,3]) - >>> f.equal_trunc(h, 3) - True - >>> f.equal_trunc(h, 4) - False - """ - # Only allow comparison with other fmpz_mod_poly - if not typecheck(other, fq_default_poly): - return False - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - return False - - return 1 == fq_default_poly_equal_trunc(self.val, other_c.val, n, self.ctx.field.val) - - def add_trunc(self, other, slong n): - """ - Truncate ``self`` and ``other`` to polynomials of length ``n`` and return their sum - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> h = R([1,2,3]) - >>> f.add_trunc(h, 2) - 4*x + 2 - >>> f.add_trunc(h, 3) - 6*x^2 + 4*x + 2 - """ - # Only allow addition with other fq_default_poly - if not typecheck(other, fq_default_poly): - raise TypeError("other polynomial must be of type fq_default_poly") - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - raise ValueError("other polynomial's context does not match") - - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_add_series( - res.val, self.val, other_c.val, n, res.ctx.field.val - ) - return res - - def sub_trunc(self, other, slong n): - """ - Truncate ``self`` and ``other`` to polynomials of length ``n`` and return their difference - - >>> R = fq_default_poly_ctx(163) - >>> f = R([2,3,5,7,11]) - >>> h = R([1,2,4,8,16]) - >>> f.sub_trunc(h, 2) - x + 1 - >>> f.sub_trunc(h, 4) - 162*x^3 + x^2 + x + 1 - """ - # Only allow subtraction with other fq_default_poly - if not typecheck(other, fq_default_poly): - raise TypeError("other polynomial must be of type fq_default_poly") - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - raise ValueError("other polynomial's context does not match") - - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_sub_series( - res.val, self.val, other_c.val, n, res.ctx.field.val - ) - return res - - def mul_low(self, other, slong n): - r""" - Returns the lowest ``n`` coefficients of the multiplication of ``self`` with ``other`` - - Equivalent to computing `f(x) \cdot g(x) \mod x^n` - - >>> R = fq_default_poly_ctx(163) - >>> f = R([2,3,5,7,11]) - >>> g = R([1,2,4,8,16]) - >>> f.mul_low(g, 5) - 101*x^4 + 45*x^3 + 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 3) - 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 1) - 2 - """ - # Only allow multiplication with other fq_default_poly - if not typecheck(other, fq_default_poly): - raise TypeError("other polynomial must be of type fq_default_poly") - - # Ensure the contexts match - other_c = other - if self.ctx != other_c.ctx: - raise ValueError("other polynomial's context does not match") - - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_mullow( - res.val, self.val, other_c.val, n, res.ctx.field.val - ) - return res - - def pow_trunc(self, e, slong n): - r""" - Returns ``self`` raised to the power ``e`` modulo `x^n`: - :math:`f^e \mod x^n`/ - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> f.pow_trunc(2**20, 30) == pow(f, 2**20, x**30) - True - >>> f.pow_trunc(2**20, 5) - 132*x^4 + 113*x^3 + 36*x^2 + 48*x + 6 - >>> f.pow_trunc(5**25, 5) - 147*x^4 + 98*x^3 + 95*x^2 + 33*x + 126 - """ - if e < 0: - raise ValueError("Exponent must be non-negative") - - cdef slong e_c - cdef fq_default_poly res, tmp - - try: - e_c = e - except OverflowError: - # Exponent does not fit slong - res = self.ctx.new_ctype_poly() - tmp = self.ctx.new_ctype_poly() - ebytes = e.to_bytes((e.bit_length() + 15) // 16 * 2, "big") - fq_default_poly_pow_trunc(res.val, self.val, ebytes[0] * 256 + ebytes[1], n, res.ctx.field.val) - for i in range(2, len(ebytes), 2): - fq_default_poly_pow_trunc(res.val, res.val, 1 << 16, n, res.ctx.field.val) - fq_default_poly_pow_trunc(tmp.val, self.val, ebytes[i] * 256 + ebytes[i+1], n, res.ctx.field.val) - fq_default_poly_mullow(res.val, res.val, tmp.val, n, res.ctx.field.val) - return res - - res = self.ctx.new_ctype_poly() - fq_default_poly_pow_trunc(res.val, self.val, e_c, n, res.ctx.field.val) - return res - - def sqrt_trunc(self, slong n): - """ - Returns the square root of ``self`` modulo `x^n`. - - Requires that the constant coefficient of the polynomial is one. - - >>> R = fq_default_poly_ctx(163, 3) - >>> x = R.gen() - >>> z = R.base_field().gen() - >>> f = (37*z + 54)*x**3 + (8*z + 94)*x**2 + (52*z + 142)*x + 1 - >>> h = f.sqrt_trunc(4) - >>> h - (7*z^2 + 17*z + 148)*x^3 + (151*z^2 + 114*z + 53)*x^2 + (26*z + 71)*x + 1 - >>> h.mul_low(h, 4) == f - True - """ - cdef fq_default_poly res - - # FLINT requires the constant term is one, so we need to normalise - c = self.constant_coefficient() - if c.is_zero(): - raise ZeroDivisionError("constant coefficient must be invertible (and a square in the field)") - if not c.is_square(): - raise ValueError("constant coefficient of the polynomial must be a square") - self = self / c - - res = self.ctx.new_ctype_poly() - fq_default_poly_sqrt_series( - res.val, self.val, n, res.ctx.field.val - ) - return res * c.sqrt() - - def inv_sqrt_trunc(self, slong n): - """ - Returns the inverse of the square root of ``self`` modulo `x^n`. - - Requires that the constant coefficient of the polynomial is one. - - >>> R = fq_default_poly_ctx(65537, 2) - >>> x = R.gen() - >>> z = R.base_field().gen() - >>> f = 28902*x**3 + (49416*z + 58229)*x**2 + 9441*z*x + (7944*z + 57534) - >>> h = f.inv_sqrt_trunc(3) - >>> h # doctest: +SKIP - (23030*z + 8965)*x^2 + (43656*z + 7173)*x + (27935*z + 28199) - >>> (h*h).mul_low(f, 3).is_one() - True - """ - cdef fq_default_poly res - - # FLINT requires the constant term is one, so we need to normalise - c = self.constant_coefficient() - if c.is_zero(): - raise ZeroDivisionError("constant coefficient must be invertible (and a square in the field)") - if not c.is_square(): - raise ValueError("constant coefficient of the polynomial must be a square") - self = self / c - - res = self.ctx.new_ctype_poly() - fq_default_poly_invsqrt_series( - res.val, self.val, n, res.ctx.field.val - ) - return res / c.sqrt() - - def inverse_series_trunc(self, slong n): - """ - Returns the inverse of ``self`` modulo `x^n`. - - >>> R = fq_default_poly_ctx(163, 3) - >>> x = R.gen() - >>> z = R.base_field().gen() - >>> f = (37*z + 54)*x**3 + (8*z + 94)*x**2 + (52*z + 142)*x + 1 - >>> f.inverse_series_trunc(2) - (111*z + 21)*x + 1 - >>> f.inverse_series_trunc(3) - (96*z^2 + 90*z + 21)*x^2 + (111*z + 21)*x + 1 - >>> f.inverse_series_trunc(4) - (34*z^2 + z + 2)*x^3 + (96*z^2 + 90*z + 21)*x^2 + (111*z + 21)*x + 1 - >>> h = f.inverse_series_trunc(4) - >>> f.mul_low(h, 4).is_one() - True - """ - cdef fq_default_poly res - - if self.constant_coefficient().is_zero(): - raise ZeroDivisionError("constant coefficient must be invertible") - - res = self.ctx.new_ctype_poly() - fq_default_poly_inv_series( - res.val, self.val, n, res.ctx.field.val - ) - return res - - # ==================================== - # GCD and Extended GCD - # ==================================== - - def gcd(self, other): - """ - Return the greatest common divisor of self and other. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = x*(x + 1) - >>> f.gcd(x+1) - x + 1 - >>> f.gcd(x*x) - x - - """ - cdef fq_default_poly res - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - res = self.ctx.new_ctype_poly() - fq_default_poly_gcd( - res.val, self.val, (other).val, self.ctx.field.val - ) - return res - - def xgcd(self, other): - r""" - Computes the extended gcd of self and other: (`G`, `S`, `T`) - where `G` is the ``gcd(self, other)`` and `S`, `T` are such that: - - :math:`G = \textrm{self}*S + \textrm{other}*T` - - >>> R = fq_default_poly_ctx(163) - >>> f = R([143, 19, 37, 138, 102, 127, 95]) - >>> g = R([139, 9, 35, 154, 87, 120, 24]) - >>> f.xgcd(g) - (x^3 + 128*x^2 + 123*x + 91, 17*x^2 + 49*x + 104, 21*x^2 + 5*x + 25) - >>> G, S, T = f.xgcd(g) - >>> assert G == f*S + g*T - - """ - cdef fq_default_poly G, S, T - - other = self.ctx.any_as_fq_default_poly(other) - if other is NotImplemented: - raise TypeError(f"Cannot interpret {other} as a polynomial") - - G = self.ctx.new_ctype_poly() - S = self.ctx.new_ctype_poly() - T = self.ctx.new_ctype_poly() - - fq_default_poly_xgcd( - G.val, S.val, T.val, self.val, (other).val, self.ctx.field.val - ) - - return (G, S, T) - - def inverse_mod(self, other): - """ - Returns the inverse of ``self`` modulo ``other`` - - >>> R = fq_default_poly_ctx(163) - >>> f = R([123, 129, 63, 14, 51, 76, 133]) - >>> h = R([139, 9, 35, 154, 87, 120, 24]) - >>> g = f.inverse_mod(h) - >>> g - 41*x^5 + 121*x^4 + 47*x^3 + 41*x^2 + 6*x + 5 - >>> assert f.mul_mod(g, h).is_one() - """ - G, S, _ = self.xgcd(other) - if not G.is_one(): - raise ValueError(f"polynomial has no inverse modulo other = {other}") - return S - - # ==================================== - # Derivative - # ==================================== - - def derivative(self): - """ - The formal derivative of this polynomial - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = 111*x**4 + 58*x**3 + 98*x**2 + 117*x + 7 - >>> f.derivative() - 118*x^3 + 11*x^2 + 33*x + 117 - - """ - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_derivative( - res.val, self.val, self.ctx.field.val - ) - return res - - def radical(self): - """ - Return the radical of ``self``, the product of the irreducible - factors of the polynomial. This is also referred to as the - square-free part of the polynomial. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = (x + 1)**3 * (x + 2) - >>> f.radical() - x^2 + 3*x + 2 - - """ - return self.exact_division(self.gcd(self.derivative())) - - def integral(self): - raise NotImplementedError("fq_default_integral is not available from FLINT") - - # ==================================== - # Evaluation and Composition - # ==================================== - - def evaluate(self, input): - """ - Evaluate ``self`` at a point in the base ring. This is - the same as calling the polynomial directly. - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3,4,5,6]) - >>> f.evaluate(-1) - 160 - >>> f.evaluate(-1) == f(-1) - True - """ - val = self.ctx.field.any_as_fq_default(input) - if val is NotImplemented: - raise TypeError(f"Cannot evaluate the polynomial with input: {input}") - - # When the fq_default type is FMPZ_MOD this function Segfaults for older - # FLINT versions - # See: https://github.com/flintlib/flint/issues/2046 - # TODO: - # Hack for converting self to an fmpz_mod type, needs to be improved - # and could be done when we decide exactly how to handle fq_default to - # fq_type conversions more generally - if self.ctx.field.fq_type == 5: - from flint import fmpz_mod_poly_ctx - ring = fmpz_mod_poly_ctx(self.ctx.characteristic()) - poly = ring([int(i) for i in self.coeffs()]) - return poly(int(input)) - - cdef fq_default res - res = self.ctx.field.new_ctype_fq_default() - fq_default_poly_evaluate_fq_default(res.val, self.val, (val).val, self.ctx.field.val) - return res - - def compose(self, other): - """ - Returns the composition of two polynomials - - To be precise about the order of composition, given ``self``, and ``other`` - by `f(x)`, `g(x)`, returns `f(g(x))`. - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3]) - >>> g = R([0,0,1]) - >>> f.compose(g) - 3*x^4 + 2*x^2 + 1 - >>> g.compose(f) - 9*x^4 + 12*x^3 + 10*x^2 + 4*x + 1 - """ - cdef fq_default_poly res - val = self.ctx.any_as_fq_default_poly(other) - if val is NotImplemented: - raise TypeError(f"Cannot compose the polynomial with input: {other}") - - res = self.ctx.new_ctype_poly() - fq_default_poly_compose(res.val, self.val, (val).val, self.ctx.field.val) - return res - - def compose_mod(self, other, modulus): - r""" - Returns the composition of two polynomials modulo a third. - - To be precise about the order of composition, given ``self``, and ``other`` - and ``modulus`` by `f(x)`, `g(x)` and `h(x)`, returns `f(g(x)) \mod h(x)`. - We require that `h(x)` is non-zero. - - >>> R = fq_default_poly_ctx(163) - >>> f = R([1,2,3,4,5]) - >>> g = R([3,2,1]) - >>> h = R([1,0,1,0,1]) - >>> f.compose_mod(g, h) - 63*x^3 + 100*x^2 + 17*x + 63 - >>> g.compose_mod(f, h) - 147*x^3 + 159*x^2 + 4*x + 7 - """ - cdef fq_default_poly res - val = self.ctx.any_as_fq_default_poly(other) - if val is NotImplemented: - raise TypeError(f"cannot compose the polynomial with input: {other}") - - h = self.ctx.any_as_fq_default_poly(modulus) - if h is NotImplemented: - raise TypeError(f"cannot reduce the polynomial with input: {modulus}") - - if h.is_zero(): - raise ZeroDivisionError("cannot reduce modulo zero") - - res = self.ctx.new_ctype_poly() - fq_default_poly_compose_mod(res.val, self.val, (val).val, (h).val, self.ctx.field.val) - return res - - def __call__(self, input): - if typecheck(input, fq_default_poly): - return self.compose(input) - return self.evaluate(input) - - # ==================================== - # Factoring and Root Finding - # ==================================== - - def factor_squarefree(self): - """ - Factors self into irreducible, squarefree factors, returning a tuple - ``(c, factors)`` where `c` is the content of the coefficients and - factors is a list of ``(poly, exp)`` pairs. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = (x + 1) * (x + 2) - >>> f.factor_squarefree() - (1, [(x^2 + 3*x + 2, 1)]) - >>> f = (x + 1) * (x + 2)**5 - >>> f.factor_squarefree() - (1, [(x + 1, 1), (x + 2, 5)]) - """ - cdef fq_default_poly_factor_t fac - cdef int i - - fq_default_poly_factor_init(fac, self.ctx.field.val) - fq_default_poly_factor_squarefree(fac, self.val, self.ctx.field.val) - - num = fq_default_poly_factor_length(fac, self.ctx.field.val) - res = [0] * num - - cdef fq_default_poly u - for i in range(num): - u = self.ctx.new_ctype_poly() - fq_default_poly_factor_get_poly(u.val, fac, i, self.ctx.field.val) - exp = fq_default_poly_factor_exp(fac, i, self.ctx.field.val) - res[i] = (u, exp) - - res.sort(key=_fq_default_poly_sort_key) - - return self.leading_coefficient(), res - - def factor(self): - """ - Factors self into irreducible factors, returning a tuple - ``(c, factors)`` where `c` is the content of the coefficients and - factors is a list of ``(poly, exp)`` pairs. - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = 6*x**4 + 7*x**3 + 7*x**2 + 8*x + 6 - >>> f.factor() - (6, [(x^4 + 137*x^3 + 137*x^2 + 110*x + 1, 1)]) - >>> f = (x + 1)**3 * (x + 2) - >>> f.factor() - (1, [(x + 2, 1), (x + 1, 3)]) - """ - cdef fq_default_poly_factor_t fac - cdef int i - - fq_default_poly_factor_init(fac, self.ctx.field.val) - - lead = self.leading_coefficient() - fq_default_poly_factor(fac, (lead).val, self.val, self.ctx.field.val) - - num = fq_default_poly_factor_length(fac, self.ctx.field.val) - res = [0] * num - - cdef fq_default_poly u - for i in range(num): - u = self.ctx.new_ctype_poly() - fq_default_poly_factor_get_poly(u.val, fac, i, self.ctx.field.val) - exp = fq_default_poly_factor_exp(fac, i, self.ctx.field.val) - res[i] = (u, exp) - - res.sort(key=_fq_default_poly_sort_key) - - return self.leading_coefficient(), res - - def roots(self, multiplicities=True): - r""" - Return the roots of the polynomial in the finite field - - >>> R = fq_default_poly_ctx(163) - >>> x = R.gen() - >>> f = (x - 1) * (x - 2)**3 * (x - 3)**5 - >>> f.roots() - [(1, 1), (2, 3), (3, 5)] - >>> f.roots(multiplicities=False) # doctest: +SKIP - [1, 2, 3] - """ - cdef fq_default_poly_factor_t fac - cdef int i, with_multiplicity - - with_multiplicity = 0 - if multiplicities: - with_multiplicity = 1 - - fq_default_poly_factor_init(fac, self.ctx.field.val) - fq_default_poly_roots(fac, self.val, with_multiplicity, self.ctx.field.val) - - num = fq_default_poly_factor_length(fac, self.ctx.field.val) - res = [0] * num - - cdef fq_default_poly linear_factor - cdef fq_default root - - for i in range(num): - # Get a factor of the form (x - a) - linear_factor = self.ctx.new_ctype_poly() - fq_default_poly_factor_get_poly(linear_factor.val, fac, i, self.ctx.field.val) - - # Compute a from (x - a) - root = self.ctx.field.new_ctype_fq_default() - fq_default_poly_get_coeff( - root.val, linear_factor.val, 0, root.ctx.val - ) - fq_default_neg( - root.val, root.val, root.ctx.val - ) - if multiplicities: - mul = fq_default_poly_factor_exp(fac, i, self.ctx.field.val) - res[i] = (root, mul) - else: - res[i] = root - return res - - def real_roots(self): - """ - This method is not implemented for polynomials in finite fields - """ - raise DomainError("Cannot compute real roots for polynomials over finite fields") - - def complex_roots(self): - """ - This method is not implemented for polynomials in finite fields - """ - raise DomainError("Cannot compute complex roots for polynomials over finite fields") - - # ==================================== - # Inflation and Deflation - # ==================================== - - def inflate(self, ulong n): - r""" - Returns the result of the polynomial `f = \textrm{self}` to - `f(x^n)` - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R([1,2,3]) - >>> f.inflate(10) - 3*x^20 + 2*x^10 + 1 - - """ - cdef fq_default_poly res - res = self.ctx.new_ctype_poly() - fq_default_poly_inflate( - res.val, self.val, n, res.ctx.field.val - ) - return res - - def deflate(self, ulong n): - r""" - Returns the result of the polynomial `f = \textrm{self}` to - `f(x^{1/n})` - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R([1,0,2,0,3]) - >>> f - 3*x^4 + 2*x^2 + 1 - >>> f.deflate(2) - 3*x^2 + 2*x + 1 - - """ - cdef fq_default_poly res - - n_max = fq_default_poly_deflation( - self.val, self.ctx.field.val - ) - if n > n_max: - raise ValueError(f"Cannot deflate with n = {n}, maximum allowed value is n_max = {n_max}") - - res = self.ctx.new_ctype_poly() - fq_default_poly_deflate( - res.val, self.val, n, res.ctx.field.val - ) - return res - - def deflation(self): - r""" - Returns the tuple (g, n) where for `f = \textrm{self}` to - `g = f(x^{1/n})` where n is the largest allowed integer - - >>> R = fq_default_poly_ctx(163, 3) - >>> f = R([1,0,2,0,3]) - >>> f - 3*x^4 + 2*x^2 + 1 - >>> f.deflate(2) - 3*x^2 + 2*x + 1 - - """ - cdef fq_default_poly res - if self.is_zero(): - return self, 1 - n = fq_default_poly_deflation( - self.val, self.ctx.field.val - ) - res = self.ctx.new_ctype_poly() - fq_default_poly_deflate( - res.val, self.val, n, res.ctx.field.val - ) - return res, int(n) diff --git a/src/flint/types/meson.build b/src/flint/types/meson.build deleted file mode 100644 index ac191e49..00000000 --- a/src/flint/types/meson.build +++ /dev/null @@ -1,116 +0,0 @@ -thisdir = 'flint/types' - -pyfiles = [ - '__init__.py', - - 'fmpz.pyi', - 'fmpz_poly.pyi', - 'fmpz_series.pyi', - 'fmpz_mpoly.pyi', - # 'fmpz_mat.pyi', - # 'fmpz_vec.pyi', - - 'fmpq.pyi', - 'fmpq_poly.pyi', - 'fmpq_series.pyi', - 'fmpq_mpoly.pyi', - # 'fmpq_mat.pyi', - # 'fmpq_vec.pyi', - - 'nmod.pyi', - 'nmod_poly.pyi', - 'nmod_mpoly.pyi', - # 'nmod_mat.pyi', - # 'nmod_series.pyi', - - 'fmpz_mod.pyi', - 'fmpz_mod_poly.pyi', - 'fmpz_mod_mpoly.pyi', - # 'fmpz_mod_mat.pyi', - - 'fq_default.pyi', - 'fq_default_poly.pyi', - - # 'arf.pyi', - # - # 'arb.pyi', - # 'arb_poly.pyi', - # 'arb_mat.pyi', - # 'arb_series.pyi', - # - # 'acb.pyi', - # 'acb_poly.pyi', - # 'acb_mat.pyi', - # 'acb_series.pyi', - # - # 'dirichlet.pyi', - # - # '_gr.pyi', -] - -exts = [ - 'fmpz', - 'fmpz_poly', - 'fmpz_mpoly', - 'fmpz_mat', - 'fmpz_series', - 'fmpz_vec', - - 'fmpq', - 'fmpq_poly', - 'fmpq_mpoly', - 'fmpq_mat', - 'fmpq_series', - 'fmpq_vec', - - 'nmod', - 'nmod_poly', - 'nmod_mpoly', - 'nmod_mat', - 'nmod_series', - - 'fmpz_mod', - 'fmpz_mod_poly', - 'fmpz_mod_mpoly', - 'fmpz_mod_mat', - - 'fq_default', - 'fq_default_poly', - - 'arf', - - 'arb', - 'arb_poly', - 'arb_mat', - 'arb_series', - - 'acb', - 'acb_poly', - 'acb_mat', - 'acb_series', - - 'dirichlet', - - '_gr', -] - -if have_acb_theta - exts += ['acb_theta'] -endif - -py.install_sources( - pyfiles, - pure: false, - subdir: thisdir, -) - -foreach ext : exts - py.extension_module( - ext, - ext + '.pyx', - dependencies: pyflint_deps, - install: true, - subdir: thisdir, - limited_api: limited_api_version, - ) -endforeach diff --git a/src/flint/types/nmod.pxd b/src/flint/types/nmod.pxd deleted file mode 100644 index 44625f59..00000000 --- a/src/flint/types/nmod.pxd +++ /dev/null @@ -1,9 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.flintlib.types.flint cimport mp_limb_t -from flint.flintlib.functions.nmod cimport nmod_t - -cdef int any_as_nmod(mp_limb_t * val, obj, nmod_t mod) except -1 - -cdef class nmod(flint_scalar): - cdef mp_limb_t val - cdef nmod_t mod diff --git a/src/flint/types/nmod.pyi b/src/flint/types/nmod.pyi deleted file mode 100644 index 8dbe8a4e..00000000 --- a/src/flint/types/nmod.pyi +++ /dev/null @@ -1,37 +0,0 @@ -from ..flint_base.flint_base import flint_scalar -from .fmpz import fmpz -from .fmpq import fmpq - -_str = str -ifmpz = int | fmpz -ifmpq = int | fmpz | fmpq -inmod = int | fmpz | fmpq | nmod - -class nmod(flint_scalar): - def __init__(self, val: inmod, mod: int): ... - - def modulus(self) -> int: ... - - def str(self, base: int = 10, condense: int = 0) -> _str: ... - def repr(self) -> _str: ... - - def __str__(self) -> _str: ... - def __repr__(self) -> _str: ... - - def __int__(self) -> int: ... - - def __neg__(self) -> nmod: ... - def __pos__(self) -> nmod: ... - def __add__(self, other: inmod, /) -> nmod: ... - def __radd__(self, other: ifmpq, /) -> nmod: ... - def __sub__(self, other: inmod, /) -> nmod: ... - def __rsub__(self, other: ifmpq, /) -> nmod: ... - def __mul__(self, other: inmod, /) -> nmod: ... - def __rmul__(self, other: ifmpq, /) -> nmod: ... - def __truediv__(self, other: inmod, /) -> nmod: ... - def __rtruediv__(self, other: ifmpq, /) -> nmod: ... - def __pow__(self, other: ifmpz, /) -> nmod: ... - - def __invert__(self) -> nmod: ... - - def sqrt(self) -> nmod: ... diff --git a/src/flint/types/nmod.pyx b/src/flint/types/nmod.pyx deleted file mode 100644 index 0f4d7c3f..00000000 --- a/src/flint/types/nmod.pyx +++ /dev/null @@ -1,281 +0,0 @@ -from flint.flint_base.flint_base cimport flint_scalar -from flint.utils.typecheck cimport typecheck -from flint.types.fmpq cimport any_as_fmpq -from flint.types.fmpz cimport any_as_fmpz -from flint.types.fmpz cimport fmpz -from flint.types.fmpq cimport fmpq - -from flint.flintlib.types.flint cimport ulong, nmod_t, mp_limb_t -from flint.flintlib.functions.fmpz cimport fmpz_t -from flint.flintlib.functions.nmod cimport ( - nmod_init, - nmod_pow_fmpz, - nmod_neg, - nmod_add, - nmod_sub, - nmod_mul, -) -from flint.flintlib.functions.fmpz cimport fmpz_fdiv_ui, fmpz_init, fmpz_clear -from flint.flintlib.functions.fmpz cimport fmpz_set_ui, fmpz_get_ui -from flint.flintlib.functions.fmpq cimport fmpq_mod_fmpz -from flint.flintlib.functions.ulong_extras cimport n_gcdinv, n_sqrtmod - -from flint.utils.flint_exceptions import DomainError - -cdef int any_as_nmod(mp_limb_t * val, obj, nmod_t mod) except -1: - cdef int success - cdef fmpz_t t - if typecheck(obj, nmod): - if (obj).mod.n != mod.n: - raise ValueError("cannot coerce integers mod n with different n") - val[0] = (obj).val - return 1 - z = any_as_fmpz(obj) - if z is not NotImplemented: - val[0] = fmpz_fdiv_ui((z).val, mod.n) - return 1 - q = any_as_fmpq(obj) - if q is not NotImplemented: - fmpz_init(t) - fmpz_set_ui(t, mod.n) - success = fmpq_mod_fmpz(t, (q).val, t) - val[0] = fmpz_get_ui(t) - fmpz_clear(t) - if not success: - raise ZeroDivisionError("%s does not exist mod %i!" % (q, mod.n)) - return 1 - return 0 - -cdef class nmod(flint_scalar): - """ - The nmod type represents elements of Z/nZ for word-size n. - - >>> nmod(10,17) * 2 - 3 - - """ - - def __init__(self, val, mod): - cdef mp_limb_t m - m = mod - nmod_init(&self.mod, m) - if not any_as_nmod(&self.val, val, self.mod): - raise TypeError("cannot create nmod from object of type %s" % type(val)) - - def repr(self): - return "nmod(%s, %s)" % (self.val, self.mod.n) - - def str(self): - return str(int(self.val)) - - def __int__(self): - return int(self.val) - - def modulus(self): - return self.mod.n - - def __richcmp__(s, t, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("nmods cannot be ordered") - if typecheck(s, nmod) and typecheck(t, nmod): - res = ((s).val == (t).val) and \ - ((s).mod.n == (t).mod.n) - if op == 2: - return res - else: - return not res - elif typecheck(s, nmod) and typecheck(t, int): - res = s.val == (t % s.mod.n) - if op == 2: - return res - else: - return not res - return NotImplemented - - def __hash__(self): - return hash((int(self.val), self.modulus)) - - def __bool__(self): - return self.val != 0 - - def __pos__(self): - return self - - def __neg__(self): - cdef nmod r = nmod.__new__(nmod) - r.mod = self.mod - r.val = nmod_neg(self.val, self.mod) - return r - - def __add__(s, t): - cdef nmod r - cdef mp_limb_t val - if any_as_nmod(&val, t, (s).mod): - r = nmod.__new__(nmod) - r.mod = (s).mod - r.val = nmod_add(val, (s).val, r.mod) - return r - return NotImplemented - - def __radd__(s, t): - cdef nmod r - cdef mp_limb_t val - if any_as_nmod(&val, t, (s).mod): - r = nmod.__new__(nmod) - r.mod = (s).mod - r.val = nmod_add((s).val, val, r.mod) - return r - return NotImplemented - - def __sub__(s, t): - cdef nmod r - cdef mp_limb_t val - if any_as_nmod(&val, t, (s).mod): - r = nmod.__new__(nmod) - r.mod = (s).mod - r.val = nmod_sub((s).val, val, r.mod) - return r - return NotImplemented - - def __rsub__(s, t): - cdef nmod r - cdef mp_limb_t val - if any_as_nmod(&val, t, (s).mod): - r = nmod.__new__(nmod) - r.mod = (s).mod - r.val = nmod_sub(val, (s).val, r.mod) - return r - return NotImplemented - - def __mul__(s, t): - cdef nmod r - cdef mp_limb_t val - if any_as_nmod(&val, t, (s).mod): - r = nmod.__new__(nmod) - r.mod = (s).mod - r.val = nmod_mul(val, (s).val, r.mod) - return r - return NotImplemented - - def __rmul__(s, t): - cdef nmod r - cdef mp_limb_t val - if any_as_nmod(&val, t, (s).mod): - r = nmod.__new__(nmod) - r.mod = (s).mod - r.val = nmod_mul((s).val, val, r.mod) - return r - return NotImplemented - - @staticmethod - def _div_(s, t): - cdef nmod r - cdef mp_limb_t sval, tval - cdef nmod_t mod - cdef ulong tinvval - - if typecheck(s, nmod): - mod = (s).mod - sval = (s).val - if not any_as_nmod(&tval, t, mod): - return NotImplemented - else: - mod = (t).mod - tval = (t).val - if not any_as_nmod(&sval, s, mod): - return NotImplemented - - if tval == 0: - raise ZeroDivisionError("%s is not invertible mod %s" % (tval, mod.n)) - if not s: - return s - - g = n_gcdinv(&tinvval, tval, mod.n) - if g != 1: - raise ZeroDivisionError("%s is not invertible mod %s" % (tval, mod.n)) - - r = nmod.__new__(nmod) - r.mod = mod - r.val = nmod_mul(sval, tinvval, mod) - return r - - def __truediv__(s, t): - return nmod._div_(s, t) - - def __rtruediv__(s, t): - return nmod._div_(t, s) - - def __invert__(self): - cdef nmod r - cdef ulong g, inv, sval - sval = (self).val - g = n_gcdinv(&inv, sval, self.mod.n) - if g != 1: - raise ZeroDivisionError("%s is not invertible mod %s" % (sval, self.mod.n)) - r = nmod.__new__(nmod) - r.mod = self.mod - r.val = inv - return r - - def __pow__(self, exp, modulus=None): - cdef nmod r - cdef mp_limb_t rval, mod - cdef ulong g, rinv - - if modulus is not None: - raise TypeError("three-argument pow() not supported by nmod") - - e = any_as_fmpz(exp) - if e is NotImplemented: - return NotImplemented - - rval = (self).val - mod = (self).mod.n - - # XXX: It is not clear that it is necessary to special case negative - # exponents here. The nmod_pow_fmpz function seems to handle this fine - # but the Flint docs say that the exponent must be nonnegative. - if e < 0: - g = n_gcdinv(&rinv, rval, mod) - if g != 1: - raise ZeroDivisionError("%s is not invertible mod %s" % (rval, mod)) - rval = rinv - e = -e - - r = nmod.__new__(nmod) - r.mod = self.mod - r.val = nmod_pow_fmpz(rval, (e).val, self.mod) - return r - - def sqrt(self): - """ - Return the square root of this nmod or raise an exception. - - >>> s = nmod(10, 13).sqrt() - >>> s - 6 - >>> s * s - 10 - >>> nmod(11, 13).sqrt() - Traceback (most recent call last): - ... - flint.utils.flint_exceptions.DomainError: no square root exists for 11 mod 13 - - The modulus must be prime. - - """ - cdef nmod r - cdef mp_limb_t val - r = nmod.__new__(nmod) - r.mod = self.mod - - if self.val == 0: - return r - - val = n_sqrtmod(self.val, self.mod.n) - if val == 0: - raise DomainError("no square root exists for %s mod %s" % (self.val, self.mod.n)) - - r.val = val - return r diff --git a/src/flint/types/nmod_mat.pxd b/src/flint/types/nmod_mat.pxd deleted file mode 100644 index b6fe89b6..00000000 --- a/src/flint/types/nmod_mat.pxd +++ /dev/null @@ -1,11 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mat - -from flint.flintlib.functions.nmod_mat cimport nmod_mat_t -from flint.flintlib.types.flint cimport mp_limb_t - -cdef class nmod_mat(flint_mat): - cdef nmod_mat_t val - cpdef long nrows(self) - cpdef long ncols(self) - cpdef mp_limb_t modulus(self) - cdef __mul_nmod(self, mp_limb_t c) diff --git a/src/flint/types/nmod_mat.pyx b/src/flint/types/nmod_mat.pyx deleted file mode 100644 index 3da5108a..00000000 --- a/src/flint/types/nmod_mat.pyx +++ /dev/null @@ -1,558 +0,0 @@ -cimport cython - -from flint.flintlib.types.flint cimport ulong, mp_limb_t -from flint.flintlib.functions.nmod cimport nmod_t - -from flint.flintlib.functions.nmod_poly cimport ( - nmod_poly_init, -) - -from flint.flintlib.functions.fmpz_mat cimport fmpz_mat_nrows, fmpz_mat_ncols -from flint.flintlib.functions.fmpz_mat cimport fmpz_mat_get_nmod_mat - -from flint.flintlib.types.nmod cimport nmod_mat_struct - -from flint.flintlib.types.nmod cimport nmod_mat_entry -from flint.flintlib.types.undocumented cimport nmod_mat_is_square - -from flint.flintlib.functions.nmod_mat cimport ( - nmod_mat_init, - nmod_mat_init_set, - nmod_mat_clear, - nmod_mat_nrows, - nmod_mat_ncols, - nmod_mat_set_entry, - nmod_mat_equal, - nmod_mat_is_zero, - nmod_mat_transpose, - nmod_mat_scalar_mul, - nmod_mat_neg, - nmod_mat_add, - nmod_mat_sub, - nmod_mat_mul, - nmod_mat_pow, - nmod_mat_inv, - nmod_mat_solve, - nmod_mat_nullspace, - nmod_mat_det, - nmod_mat_rref, - nmod_mat_rank, - nmod_mat_charpoly, - nmod_mat_minpoly, - nmod_mat_randtest, -) - -from flint.utils.typecheck cimport typecheck -from flint.types.fmpz_mat cimport any_as_fmpz_mat -from flint.types.fmpz_mat cimport fmpz_mat -from flint.types.nmod cimport nmod -from flint.types.nmod cimport any_as_nmod -from flint.types.nmod_poly cimport nmod_poly -from flint.pyflint cimport global_random_state -from flint.flint_base.flint_context cimport thectx - -from flint.flint_base.flint_base cimport flint_mat - - -ctx = thectx - - -cdef any_as_nmod_mat(obj, nmod_t mod): - cdef nmod_mat r - if typecheck(obj, nmod_mat): - return obj - x = any_as_fmpz_mat(obj) - if x is not NotImplemented: - r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, - fmpz_mat_nrows((x).val), - fmpz_mat_ncols((x).val), mod.n) - fmpz_mat_get_nmod_mat(r.val, (x).val) - return r - return NotImplemented - - -cdef class nmod_mat(flint_mat): - """ - The nmod_mat type represents dense matrices over Z/nZ for word-size n (see - fmpz_mod_mat for larger moduli). - - Some operations may assume that n is a prime. - """ - -# cdef nmod_mat_t val - - def __dealloc__(self): - nmod_mat_clear(self.val) - - @cython.embedsignature(False) - def __init__(self, *args): - cdef long m, n, i, j - cdef mp_limb_t mod - if len(args) == 1: - val = args[0] - if typecheck(val, nmod_mat): - nmod_mat_init_set(self.val, (val).val) - return - mod = args[-1] - args = args[:-1] - if mod == 0: - raise ValueError("modulus must be nonzero") - if len(args) == 1: - val = args[0] - if typecheck(val, fmpz_mat): - nmod_mat_init(self.val, fmpz_mat_nrows((val).val), - fmpz_mat_ncols((val).val), mod) - fmpz_mat_get_nmod_mat(self.val, (val).val) - elif isinstance(val, (list, tuple)): - m = len(val) - n = 0 - if m != 0: - if not isinstance(val[0], (list, tuple)): - raise TypeError("single input to nmod_mat must be a list of lists") - n = len(val[0]) - for i from 1 <= i < m: - if len(val[i]) != n: - raise ValueError("input rows have different lengths") - nmod_mat_init(self.val, m, n, mod) - for i from 0 <= i < m: - row = val[i] - for j from 0 <= j < n: - x = nmod(row[j], mod) - nmod_mat_set_entry(self.val, i, j, x.val) - else: - raise TypeError("cannot create nmod_mat from input of type %s" % type(val)) - elif len(args) == 2: - m, n = args - nmod_mat_init(self.val, m, n, mod) - elif len(args) == 3: - m, n, entries = args - nmod_mat_init(self.val, m, n, mod) - entries = list(entries) - if len(entries) != m*n: - raise ValueError("list of entries has the wrong length") - for i from 0 <= i < m: - for j from 0 <= j < n: - x = nmod(entries[i*n + j], mod) # XXX: slow - nmod_mat_set_entry(self.val, i, j, x.val) - else: - raise TypeError("nmod_mat: expected 1-3 arguments plus modulus") - - def __bool__(self): - return not nmod_mat_is_zero(self.val) - - def __richcmp__(s, t, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("matrices cannot be ordered") - if typecheck(s, nmod_mat) and typecheck(t, nmod_mat): - if (s).val.mod.n != (t).val.mod.n: - res = False - else: - res = nmod_mat_equal((s).val, (t).val) - if op == 2: - return res - if op == 3: - return not res - return NotImplemented - - cpdef long nrows(self): - return nmod_mat_nrows(self.val) - - cpdef long ncols(self): - return nmod_mat_ncols(self.val) - - cpdef mp_limb_t modulus(self): - return self.val.mod.n - - @classmethod - def randtest(cls, ulong m, ulong n, ulong mod): - """ - Returns a random (m, n) matrix with non-uniformly chosen - entries. Zero entries are generated with increased probability. - """ - cdef nmod_mat mat = nmod_mat(m, n, mod) - nmod_mat_randtest(mat.val, global_random_state) - return mat - - def repr(self): - m = self.nrows() - n = self.ncols() - entries = ', '.join(map(str, self.entries())) - return f"nmod_mat({m}, {n}, [{entries}], {self.modulus()})" - - def entries(self): - cdef long i, j, m, n - cdef nmod t - m = self.nrows() - n = self.ncols() - L = [None] * (m * n) - for i from 0 <= i < m: - for j from 0 <= j < n: - # XXX - t = nmod(nmod_mat_entry(self.val, i, j), self.val.mod.n) - L[i*n + j] = t - return L - - def __getitem__(self, index): - cdef long i, j - cdef nmod x - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - x = nmod(nmod_mat_entry(self.val, i, j), self.modulus()) # XXX: slow - return x - - def __setitem__(self, index, value): - cdef long i, j - cdef mp_limb_t v - i, j = index - if i < 0 or i >= self.nrows() or j < 0 or j >= self.ncols(): - raise IndexError("index %i,%i exceeds matrix dimensions" % (i, j)) - if any_as_nmod(&v, value, self.val.mod): - nmod_mat_set_entry(self.val, i, j, v) - else: - raise TypeError("cannot set item of type %s" % type(value)) - - def __pos__(self): - return self - - def __neg__(self): - cdef nmod_mat r = nmod_mat(self) # XXX - nmod_mat_neg(r.val, r.val) - return r - - def __add__(s, t): - cdef nmod_mat r - cdef nmod_mat_struct *sv - cdef nmod_mat_struct *tv - sv = &(s).val[0] - t = any_as_nmod_mat(t, sv.mod) - if t is NotImplemented: - return t - tv = &(t).val[0] - if sv.mod.n != tv.mod.n: - raise ValueError("cannot add nmod_mats with different moduli") - if sv.r != tv.r or sv.c != tv.c: - raise ValueError("incompatible shapes for matrix addition") - r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, sv.r, sv.c, sv.mod.n) - nmod_mat_add(r.val, sv, tv) - return r - - def __radd__(s, t): - cdef nmod_mat r - cdef nmod_mat_struct *sv - cdef nmod_mat_struct *tv - sv = &(s).val[0] - t = any_as_nmod_mat(t, sv.mod) - if t is NotImplemented: - return t - tv = &(t).val[0] - if sv.mod.n != tv.mod.n: - raise ValueError("cannot add nmod_mats with different moduli") - if sv.r != tv.r or sv.c != tv.c: - raise ValueError("incompatible shapes for matrix addition") - r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, sv.r, sv.c, sv.mod.n) - nmod_mat_add(r.val, sv, tv) - return r - - def __sub__(s, t): - cdef nmod_mat r - cdef nmod_mat_struct *sv - cdef nmod_mat_struct *tv - sv = &(s).val[0] - t = any_as_nmod_mat(t, sv.mod) - if t is NotImplemented: - return t - tv = &(t).val[0] - if sv.mod.n != tv.mod.n: - raise ValueError("cannot subtract nmod_mats with different moduli") - if sv.r != tv.r or sv.c != tv.c: - raise ValueError("incompatible shapes for matrix subtraction") - r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, sv.r, sv.c, sv.mod.n) - nmod_mat_sub(r.val, sv, tv) - return r - - def __rsub__(s, t): - cdef nmod_mat r - cdef nmod_mat_struct *sv - cdef nmod_mat_struct *tv - sv = &(s).val[0] - t = any_as_nmod_mat(t, sv.mod) - if t is NotImplemented: - return t - tv = &(t).val[0] - if sv.mod.n != tv.mod.n: - raise ValueError("cannot subtract nmod_mats with different moduli") - if sv.r != tv.r or sv.c != tv.c: - raise ValueError("incompatible shapes for matrix subtraction") - r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, sv.r, sv.c, sv.mod.n) - nmod_mat_sub(r.val, tv, sv) - return r - - cdef __mul_nmod(self, mp_limb_t c): - cdef nmod_mat r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, self.val.r, self.val.c, self.val.mod.n) - nmod_mat_scalar_mul(r.val, self.val, c) - return r - - def __mul__(s, t): - cdef nmod_mat r - cdef nmod_mat_struct *sv - cdef nmod_mat_struct *tv - cdef mp_limb_t c - sv = &(s).val[0] - u = any_as_nmod_mat(t, sv.mod) - if u is NotImplemented: - if any_as_nmod(&c, t, sv.mod): - return (s).__mul_nmod(c) - return NotImplemented - tv = &(u).val[0] - if sv.mod.n != tv.mod.n: - raise ValueError("cannot multiply nmod_mats with different moduli") - if sv.c != tv.r: - raise ValueError("incompatible shapes for matrix multiplication") - r = nmod_mat.__new__(nmod_mat) - nmod_mat_init(r.val, sv.r, tv.c, sv.mod.n) - nmod_mat_mul(r.val, sv, tv) - return r - - def __rmul__(s, t): - cdef nmod_mat_struct *sv - cdef mp_limb_t c - sv = &(s).val[0] - if any_as_nmod(&c, t, sv.mod): - return (s).__mul_nmod(c) - u = any_as_nmod_mat(t, sv.mod) - if u is NotImplemented: - return u - return u * s - - def __pow__(self, e, m): - cdef nmod_mat t - cdef ulong ee - if not self.nrows() == self.ncols(): - raise ValueError("matrix must be square") - if m is not None: - raise NotImplementedError("modular matrix exponentiation") - if e < 0: - self = self.inv() - e = -e - ee = e - t = nmod_mat(self) # XXX - nmod_mat_pow(t.val, t.val, ee) - return t - - @staticmethod - def _div_(nmod_mat s, t): - cdef mp_limb_t v - if not any_as_nmod(&v, t, s.val.mod): - return NotImplemented - t = nmod(v, s.val.mod.n) - return s * (~t) - - def __truediv__(s, t): - return nmod_mat._div_(s, t) - - def __div__(s, t): - return nmod_mat._div_(s, t) - - def det(self): - """ - Returns the determinant of self as an nmod. - - >>> nmod_mat(2,2,[1,2,3,4],17).det() - 15 - - """ - if not nmod_mat_is_square(self.val): - raise ValueError("matrix must be square") - return nmod(nmod_mat_det(self.val), self.modulus()) - - def inv(self): - """ - Returns the inverse of self. - - >>> from flint import nmod_mat - >>> A = nmod_mat(2,2,[1,2,3,4],17) - >>> A.inv() - [15, 1] - [10, 8] - - """ - cdef nmod_mat u - if not nmod_mat_is_square(self.val): - raise ValueError("matrix must be square") - u = nmod_mat.__new__(nmod_mat) - nmod_mat_init(u.val, nmod_mat_nrows(self.val), - nmod_mat_ncols(self.val), self.val.mod.n) - if not nmod_mat_inv(u.val, self.val): - raise ZeroDivisionError("matrix is singular") - return u - - def transpose(self): - """ - Returns the transpose of self. - - >>> nmod_mat(2,3,range(6),7).transpose() - [0, 3] - [1, 4] - [2, 5] - """ - cdef nmod_mat u - u = nmod_mat.__new__(nmod_mat) - nmod_mat_init(u.val, nmod_mat_ncols(self.val), - nmod_mat_nrows(self.val), self.val.mod.n) - nmod_mat_transpose(u.val, self.val) - return u - - def solve(self, other): - """ - Given self = A and other = B, returns a matrix X such - that A*X = B, assuming that self is square and invertible. - - >>> A = nmod_mat(2, 2, [1,4,8,3], 11) - >>> B = nmod_mat(2, 3, range(6), 11) - >>> X = A.solve(B) - >>> X - [8, 5, 2] - [9, 10, 0] - >>> A*X == B - True - >>> nmod_mat(2, 2, [1,0,2,0], 11).solve(B) - Traceback (most recent call last): - ... - ZeroDivisionError: singular matrix in solve() - >>> A.solve(nmod_mat(1, 2, [2,3], 11)) - Traceback (most recent call last): - ... - ValueError: need a square system and compatible right hand side - - """ - cdef nmod_mat u - cdef int result - t = any_as_nmod_mat(other, self.val.mod) - if t is NotImplemented: - raise TypeError("cannot convert input to nmod_mat") - if (nmod_mat_nrows(self.val) != nmod_mat_ncols(self.val) or - nmod_mat_nrows(self.val) != nmod_mat_nrows((t).val)): - raise ValueError("need a square system and compatible right hand side") - u = nmod_mat.__new__(nmod_mat) - nmod_mat_init(u.val, nmod_mat_nrows((t).val), - nmod_mat_ncols((t).val), self.val.mod.n) - result = nmod_mat_solve(u.val, self.val, (t).val) - if not result: - raise ZeroDivisionError("singular matrix in solve()") - return u - - def rref(self, inplace=False): - """ - Computes the reduced row echelon form (rref) of self, - either returning a new copy or modifying self in-place. - Returns (rref, rank). - - >>> A = nmod_mat(3,3,range(9),23) - >>> A.rref() - ([1, 0, 22] - [0, 1, 2] - [0, 0, 0], 2) - >>> A.rref(inplace=True) - ([1, 0, 22] - [0, 1, 2] - [0, 0, 0], 2) - >>> A - [1, 0, 22] - [0, 1, 2] - [0, 0, 0] - - """ - if inplace: - res = self - else: - res = nmod_mat.__new__(nmod_mat) - nmod_mat_init_set((res).val, self.val) - rank = nmod_mat_rref((res).val) - return res, rank - - def rank(self): - """Return the rank of a matrix. - - >>> from flint import nmod_mat - >>> M = nmod_mat([[1, 2], [3, 4]], 11) - >>> M.rank() - 2 - """ - return nmod_mat_rank(self.val) - - def nullspace(self): - """ - Computes a basis for the nullspace of self. Returns (X, nullity) - where nullity is the rank of the nullspace of self and X is a - matrix whose first (nullity) columns are linearly independent, - and such that self * X = 0. - - >>> A = nmod_mat(3,5,range(1,16),23) - >>> X, nullity = A.nullspace() - >>> A.rank(), nullity, X.rank() - (2, 3, 3) - >>> A * X - [0, 0, 0, 0, 0] - [0, 0, 0, 0, 0] - [0, 0, 0, 0, 0] - >>> X - [ 1, 2, 3, 0, 0] - [21, 20, 19, 0, 0] - [ 1, 0, 0, 0, 0] - [ 0, 1, 0, 0, 0] - [ 0, 0, 1, 0, 0] - - """ - cdef nmod_mat res - res = nmod_mat.__new__(nmod_mat) - nmod_mat_init(res.val, nmod_mat_ncols(self.val), nmod_mat_ncols(self.val), self.val.mod.n) - nullity = nmod_mat_nullspace(res.val, self.val) - return res, nullity - - def charpoly(self): - """Return the characteristic polynomial of a matrix. - - >>> from flint import nmod_mat - >>> M = nmod_mat([[1, 2], [3, 4]], 11) - >>> M.charpoly() - x^2 + 6*x + 9 - - """ - cdef nmod_poly res - - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat charpoly: matrix must be square") - - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init(res.val, self.val.mod.n) - nmod_mat_charpoly(res.val, self.val) - return res - - def minpoly(self): - """Return the minimal polynomial of a matrix. - - >>> 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 - - """ - cdef nmod_poly res - - if self.nrows() != self.ncols(): - raise ValueError("fmpz_mod_mat minpoly: matrix must be square") - - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init(res.val, self.val.mod.n) - nmod_mat_minpoly(res.val, self.val) - return res diff --git a/src/flint/types/nmod_mpoly.pxd b/src/flint/types/nmod_mpoly.pxd deleted file mode 100644 index 8a44d87d..00000000 --- a/src/flint/types/nmod_mpoly.pxd +++ /dev/null @@ -1,36 +0,0 @@ -from flint.flint_base.flint_base cimport flint_mpoly, flint_mod_mpoly_context - -from flint.flintlib.functions.nmod_mpoly cimport ( - nmod_mpoly_ctx_t, - nmod_mpoly_t, - nmod_mpoly_init, - nmod_mpoly_struct -) -from flint.flintlib.types.flint cimport slong, ulong - -cdef inline init_nmod_mpoly(nmod_mpoly var, nmod_mpoly_ctx ctx): - var.ctx = ctx - nmod_mpoly_init(var.val, ctx.val) - var._init = True - -cdef inline nmod_mpoly create_nmod_mpoly(nmod_mpoly_ctx ctx): - cdef nmod_mpoly var - var = nmod_mpoly.__new__(nmod_mpoly) - var.ctx = ctx - nmod_mpoly_init(var.val, ctx.val) - var._init = True - return var - -cdef class nmod_mpoly_ctx(flint_mod_mpoly_context): - cdef nmod_mpoly_ctx_t val - -cdef class nmod_mpoly(flint_mpoly): - cdef nmod_mpoly_t val - cdef nmod_mpoly_ctx ctx - cdef bint _init - -cdef class nmod_mpoly_vec: - cdef nmod_mpoly_struct *val - cdef slong length - cdef nmod_mpoly_ctx ctx - cdef nmod_mpoly_struct **double_indirect diff --git a/src/flint/types/nmod_mpoly.pyi b/src/flint/types/nmod_mpoly.pyi deleted file mode 100644 index 183d045a..00000000 --- a/src/flint/types/nmod_mpoly.pyi +++ /dev/null @@ -1,139 +0,0 @@ -from typing import Iterable, Mapping, Self, Any -from ..flint_base.flint_base import ( - flint_mpoly, - flint_mpoly_context, - flint_mod_mpoly_context, - Ordering, -) -from .fmpz import fmpz -from .fmpq import fmpq -from .nmod import nmod -from .fmpz_mpoly import fmpz_mpoly - - -_str = str -ifmpz = int | fmpz -inmod = int | fmpz | fmpq | nmod - - -class nmod_mpoly_ctx(flint_mod_mpoly_context[nmod_mpoly, nmod, inmod]): - - @classmethod - def get(cls, - names: _str | Iterable[_str | tuple[_str, int]] | tuple[_str, int], - ordering: Ordering | _str = Ordering.lex, - *, - modulus: int, - ) -> nmod_mpoly_ctx: - ... - - def modulus(self) -> int: ... - - def nvars(self) -> int: ... - def ordering(self) -> Ordering: ... - - def gen(self, i: int) -> nmod_mpoly: ... - def from_dict(self, d: Mapping[tuple[int, ...], inmod]) -> nmod_mpoly: ... - def constant(self, z: inmod) -> nmod_mpoly: ... - - def name(self, i: int, /) -> str: ... - def names(self) -> tuple[str, ...]: ... - def gens(self) -> tuple[nmod_mpoly, ...]: ... - def variable_to_index(self, var: str, /) -> int: ... - def term( - self, coeff: inmod | None = None, exp_vec: Iterable[int] | None = None - ) -> nmod_mpoly: ... - def drop_gens(self, gens: Iterable[str | int], /) -> nmod_mpoly_ctx: ... - def append_gens(self, gens: Iterable[str | int], /) -> nmod_mpoly_ctx: ... - def infer_generator_mapping( - self, ctx: flint_mpoly_context, / - ) -> dict[int, int]: ... - @classmethod - def from_context( - cls, - ctx: flint_mpoly_context[Any, Any, Any], - names: str | Iterable[str | tuple[str, int]] | tuple[str, int] | None = None, - ordering: Ordering | str = Ordering.lex, - ) -> nmod_mpoly_ctx: ... - - -class nmod_mpoly(flint_mpoly[nmod_mpoly_ctx, nmod, inmod]): - def __init__(self, - val: nmod_mpoly | fmpz_mpoly | inmod | Mapping[tuple[int, ...], inmod] | _str = 0, - ctx: nmod_mpoly_ctx | None = None - ) -> None: ... - - def str(self) -> _str: ... - def repr(self) -> _str: ... - - def context(self) -> nmod_mpoly_ctx: ... - - def degrees(self) -> tuple[int, ...]: ... - def total_degree(self) -> int: ... - - def is_one(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_constant(self) -> bool: ... - - def __len__(self) -> int: ... - def coefficient(self, i: int) -> nmod: ... - def monomial(self, i: int) -> tuple[int, ...]: ... - - def monoms(self) -> list[tuple[int, ...]]: ... - def coeffs(self) -> list[nmod]: ... - def __getitem__(self, index: tuple[int, ...]) -> nmod: ... - def __setitem__(self, index: tuple[int, ...], coeff: inmod) -> None: ... - - def subs(self, mapping: Mapping[_str | int, inmod]) -> nmod_mpoly: ... - def compose(self, *args: nmod_mpoly, ctx: nmod_mpoly_ctx | None = None) -> nmod_mpoly: ... - - def __call__(self, *args: inmod) -> nmod: ... - - def __pos__(self) -> nmod_mpoly: ... - def __neg__(self) -> nmod_mpoly: ... - def __add__(self, other: nmod_mpoly | inmod) -> nmod_mpoly: ... - def __radd__(self, other: inmod) -> nmod_mpoly: ... - def __sub__(self, other: nmod_mpoly | inmod) -> nmod_mpoly: ... - def __rsub__(self, other: inmod) -> nmod_mpoly: ... - def __mul__(self, other: nmod_mpoly | inmod) -> nmod_mpoly: ... - def __rmul__(self, other: inmod) -> nmod_mpoly: ... - def __truediv__(self, other: nmod_mpoly | inmod) -> nmod_mpoly: ... - def __rtruediv__(self, other: inmod) -> nmod_mpoly: ... - def __floordiv__(self, other: nmod_mpoly | inmod) -> nmod_mpoly: ... - def __rfloordiv__(self, other: inmod) -> nmod_mpoly: ... - def __mod__(self, other: nmod_mpoly | inmod) -> nmod_mpoly: ... - def __rmod__(self, other: inmod) -> nmod_mpoly: ... - def __divmod__(self, other: nmod_mpoly | inmod) -> tuple[nmod_mpoly, nmod_mpoly]: ... - def __rdivmod__(self, other: inmod) -> tuple[nmod_mpoly, nmod_mpoly]: ... - def __pow__(self, other: inmod) -> nmod_mpoly: ... - def __rpow__(self, other: inmod) -> nmod_mpoly: ... - - def iadd(self, other: nmod_mpoly | inmod) -> None: ... - def isub(self, other: nmod_mpoly | inmod) -> None: ... - def imul(self, other: nmod_mpoly | inmod) -> None: ... - - def gcd(self, other: nmod_mpoly) -> nmod_mpoly: ... - def xgcd(self, other: nmod_mpoly, /) -> nmod: ... - def term_content(self) -> nmod_mpoly: ... - def primitive(self) -> tuple[nmod, nmod_mpoly]: ... - - def factor(self) -> tuple[nmod, list[tuple[nmod_mpoly, int]]]: ... - def factor_squarefree(self) -> tuple[nmod, list[tuple[nmod_mpoly, int]]]: ... - - def sqrt(self, assume_perfect_square: bool = False) -> nmod_mpoly: ... - - def resultant(self, other: Self, var: _str | int) -> Self: ... - def discriminant(self, var: _str | int) -> nmod_mpoly: ... - - def deflation(self) -> tuple[nmod_mpoly, list[int]]: ... - def inflate(self, N: list[int]) -> nmod_mpoly: ... - def deflate(self, N: list[int]) -> nmod_mpoly: ... - def deflation_monom(self) -> tuple[nmod_mpoly, list[int], nmod_mpoly]: ... - def deflation_index(self) -> tuple[list[int], list[int]]: ... - - def derivative(self, var: _str | int) -> nmod_mpoly: ... - - -class nmod_mpoly_vec: - ... - diff --git a/src/flint/types/nmod_mpoly.pyx b/src/flint/types/nmod_mpoly.pyx deleted file mode 100644 index 8abbc5c4..00000000 --- a/src/flint/types/nmod_mpoly.pyx +++ /dev/null @@ -1,1204 +0,0 @@ -cimport cython - -from flint.flint_base.flint_base cimport ( - flint_mpoly, - flint_mod_mpoly_context, - ordering_py_to_c, - ordering_c_to_py, -) - -from flint.utils.typecheck cimport typecheck -from flint.utils.flint_exceptions import DomainError, IncompatibleContextError - -from flint.types.fmpz cimport fmpz -from flint.types.fmpz_vec cimport fmpz_vec -from flint.types.fmpz_mod cimport fmpz_mod - -from flint.types.nmod cimport nmod - -from flint.flintlib.types.flint cimport SIZEOF_ULONG -from flint.flintlib.functions.fmpz cimport fmpz_set, fmpz_get_nmod - -from flint.flintlib.functions.nmod_mpoly cimport ( - nmod_mpoly_add, - nmod_mpoly_add_ui, - nmod_mpoly_clear, - nmod_mpoly_compose_nmod_mpoly_gen, - nmod_mpoly_compose_nmod_mpoly, - nmod_mpoly_ctx_init, - nmod_mpoly_ctx_modulus, - nmod_mpoly_degrees_fmpz, - nmod_mpoly_derivative, - nmod_mpoly_discriminant, - nmod_mpoly_div, - nmod_mpoly_divides, - nmod_mpoly_divrem, - nmod_mpoly_equal, - nmod_mpoly_equal_ui, - nmod_mpoly_evaluate_all_ui, - nmod_mpoly_evaluate_one_ui, - nmod_mpoly_gcd, - nmod_mpoly_gen, - nmod_mpoly_get_coeff_ui_fmpz, - nmod_mpoly_get_str_pretty, - nmod_mpoly_get_term_coeff_ui, - nmod_mpoly_get_term_exp_fmpz, - nmod_mpoly_is_one, - nmod_mpoly_is_zero, - nmod_mpoly_length, - nmod_mpoly_mul, - nmod_mpoly_neg, - nmod_mpoly_pow_fmpz, - nmod_mpoly_push_term_ui_ffmpz, - nmod_mpoly_resultant, - nmod_mpoly_scalar_mul_ui, - nmod_mpoly_set, - nmod_mpoly_set_coeff_ui_fmpz, - nmod_mpoly_set_str_pretty, - nmod_mpoly_set_ui, - nmod_mpoly_sort_terms, - nmod_mpoly_sqrt, - nmod_mpoly_sub, - nmod_mpoly_sub_ui, - nmod_mpoly_term_content, - nmod_mpoly_total_degree_fmpz, -) -from flint.flintlib.functions.nmod_mpoly_factor cimport ( - nmod_mpoly_factor, - nmod_mpoly_factor_clear, - nmod_mpoly_factor_init, - nmod_mpoly_factor_squarefree, - nmod_mpoly_factor_t, -) -from flint.flintlib.functions.ulong_extras cimport n_is_prime -from flint.flintlib.types.undocumented cimport ( - nmod_mpoly_deflate, - nmod_mpoly_deflation, - nmod_mpoly_inflate, -) - -from cpython.object cimport Py_EQ, Py_NE -cimport libc.stdlib - -cdef dict _nmod_mpoly_ctx_cache = {} - - -cdef class nmod_mpoly_ctx(flint_mod_mpoly_context): - """ - A class for storing the polynomial context - - :param names: A tuple containing the names of the variables of the ring. - :param ordering: The term order for the ring. - :param modulus: The modulus for the ring. - - Do not construct one of these directly, use ``nmod_mpoly_ctx.get``. - """ - - _ctx_cache = _nmod_mpoly_ctx_cache - - @classmethod - def _new_(cls, names, ordering, modulus: int): - cdef nmod_mpoly_ctx self = cls.__new__(cls) - - if modulus <= 0: - raise ValueError("modulus must be positive") - - super()._new_(self, names, n_is_prime(modulus)) - nmod_mpoly_ctx_init(self.val, len(names), ordering_py_to_c(ordering), modulus) - return self - - def _any_as_scalar(self, other): - if isinstance(other, int): - try: - return other - except OverflowError: - return (other % self.modulus()) - elif typecheck(other, nmod): - return (other).val - elif typecheck(other, fmpz): - return fmpz_get_nmod((other).val, self.val.mod) - elif typecheck(other, fmpz_mod): - return fmpz_get_nmod((other).val, self.val.mod) - else: - return NotImplemented - - def _scalar_as_mpoly(self, other: ulong): - # non-ulong scalars should first be converted via self._any_as_scalar - return self.constant(other) - - def nvars(self): - """ - Return the number of variables in the context - - >>> ctx = nmod_mpoly_ctx.get(('x', 4), 11, 'lex') - >>> ctx.nvars() - 4 - """ - return self.val.minfo.nvars - - def ordering(self): - """ - Return the term order of the context object. - - >>> ctx = nmod_mpoly_ctx.get(('w', 4), 11, 'deglex') - >>> ctx.ordering() - - """ - return ordering_c_to_py(self.val.minfo.ord) - - def modulus(self): - """ - Return the modulus of the context object. - - >>> ctx = nmod_mpoly_ctx.get(('w', 4), 2, 'deglex') - >>> ctx.modulus() - 2 - - """ - return nmod_mpoly_ctx_modulus(self.val) - - def gen(self, slong i): - """ - Return the ``i`` th generator of the polynomial ring - - >>> ctx = nmod_mpoly_ctx.get(('z', 3), 11, 'degrevlex') - >>> ctx.gen(1) - z1 - """ - cdef nmod_mpoly res - if not 0 <= i < self.val.minfo.nvars: - raise IndexError("generator index out of range") - res = create_nmod_mpoly(self) - nmod_mpoly_gen(res.val, i, res.ctx.val) - return res - - def constant(self, z): - """ - Create a constant polynomial in this context - """ - cdef nmod_mpoly res - res = create_nmod_mpoly(self) - nmod_mpoly_set_ui(res.val, z, res.ctx.val) - return res - - def from_dict(self, d): - """ - Create a nmod_mpoly from a dictionary in this context. - - The dictionary's keys are tuples of ints (or anything that implicitly converts - to fmpz) representing exponents, and corresponding values of fmpz. - - >>> ctx = nmod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> ctx.from_dict({(1,0):2, (1,1):3, (0,1):1}) - 3*x*y + 2*x + y - """ - cdef: - fmpz_vec exp_vec - slong i, nvars = self.nvars() - nmod_mpoly res - - if not isinstance(d, dict): - raise ValueError("expected a dictionary") - - res = create_nmod_mpoly(self) - - for i, (exps, coeff) in enumerate(d.items()): - if len(exps) != nvars: - raise ValueError(f"expected {nvars} exponents, got {len(exps)}") - elif not coeff: - continue - - exp_vec = fmpz_vec(exps) - coeff_scalar = self._any_as_scalar(coeff) - if coeff_scalar is NotImplemented: - raise TypeError(f"cannot coerce {repr(coeff)} to nmod_mpoly coefficient") - - nmod_mpoly_push_term_ui_ffmpz(res.val, coeff_scalar, exp_vec.val, self.val) - - nmod_mpoly_sort_terms(res.val, self.val) - return res - - -cdef class nmod_mpoly(flint_mpoly): - """ - The *nmod_mpoly* type represents sparse multivariate polynomials over - the integers. - """ - - def __cinit__(self): - self._init = False - - def __dealloc__(self): - if self._init: - nmod_mpoly_clear(self.val, self.ctx.val) - self._init = False - - def __init__(self, val=0, ctx=None): - if typecheck(val, nmod_mpoly): - if ctx is None or ctx == (val).ctx: - init_nmod_mpoly(self, (val).ctx) - nmod_mpoly_set(self.val, (val).val, self.ctx.val) - else: - raise IncompatibleContextError(f"{ctx} is not {(val).ctx}") - elif isinstance(val, dict): - if ctx is None: - raise ValueError("a context is required to create a nmod_mpoly from a dict") - x = ctx.from_dict(val) - # XXX: this copy is silly, have a ctx function that assigns an nmod_mpoly_t - init_nmod_mpoly(self, ctx) - nmod_mpoly_set(self.val, (x).val, self.ctx.val) - elif isinstance(val, str): - if ctx is None: - raise ValueError("cannot parse a polynomial without context") - val = bytes(val, 'utf-8') - init_nmod_mpoly(self, ctx) - if nmod_mpoly_set_str_pretty(self.val, val, self.ctx.c_names, self.ctx.val) == -1: - raise ValueError("unable to parse nmod_mpoly from string") - nmod_mpoly_sort_terms(self.val, self.ctx.val) - elif isinstance(val, int): - if ctx is None: - raise ValueError("need context to convert int to nmod_mpoly") - init_nmod_mpoly(self, ctx) - nmod_mpoly_set_ui(self.val, val, self.ctx.val) - else: - raise TypeError(f"cannot construct a nmod_mpoly from a {type(val)}") - - def _division_check(self, other): - super()._division_check(other) - if not self.ctx.is_prime(): - raise DomainError("division with non-prime modulus is not supported") - - def __bool__(self): - return not nmod_mpoly_is_zero(self.val, self.ctx.val) - - def is_zero(self): - return nmod_mpoly_is_zero(self.val, self.ctx.val) - - def is_one(self): - return nmod_mpoly_is_one(self.val, self.ctx.val) - - def is_constant(self): - """ - Returns True if this is a constant polynomial. - """ - return self.total_degree() <= 0 - - def __richcmp__(self, other, int op): - if not (op == Py_EQ or op == Py_NE): - return NotImplemented - elif typecheck(self, nmod_mpoly) and typecheck(other, nmod_mpoly): - if (self).ctx is (other).ctx: - return (op == Py_NE) ^ nmod_mpoly_equal(self.val, (other).val, self.ctx.val) - else: - return op == Py_NE - elif typecheck(other, nmod): - if other.modulus() != self.ctx.modulus(): - return op == Py_NE - return (op == Py_NE) ^ nmod_mpoly_equal_ui(self.val, int(other), self.ctx.val) - elif typecheck(other, fmpz): - return (op == Py_NE) ^ nmod_mpoly_equal_ui( - self.val, - fmpz_get_nmod((other).val, self.ctx.val.mod), - self.ctx.val - ) - elif isinstance(other, int): - omod = other % self.ctx.modulus() - return (op == Py_NE) ^ nmod_mpoly_equal_ui(self.val, omod, self.ctx.val) - else: - return NotImplemented - - def __len__(self): - return nmod_mpoly_length(self.val, self.ctx.val) - - def __getitem__(self, x): - """ - Return the coefficient of the term with the exponent vector ``x``. - Always returns a value, missing keys will return ``0``. - Negative exponents are made positive. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] - 3 - - """ - cdef: - slong nvars = self.ctx.nvars() - - if not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - exp_vec = fmpz_vec(x, double_indirect=True) - return nmod_mpoly_get_coeff_ui_fmpz(self.val, exp_vec.double_indirect, self.ctx.val) - - def __setitem__(self, x, y): - """ - Set the coefficient of the term with the exponent vector ``x`` to ``y``. - Will always set a value, missing keys will create a new term. - Negative exponents are made positive. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p[1, 1] = 20 - >>> p - 9*x0*x1 + 2*x1 - - """ - cdef: - slong nvars = self.ctx.nvars() - ulong coeff - - if not isinstance(x, tuple): - raise TypeError("exponent vector index is not a tuple") - elif len(x) != nvars: - raise ValueError("exponent vector provided does not match number of variables") - - exp_vec = fmpz_vec(x, double_indirect=True) - - coeff = self.ctx._any_as_scalar(y) - if coeff is NotImplemented: - raise TypeError("provided coefficient not coercible to ulong") - nmod_mpoly_set_coeff_ui_fmpz(self.val, coeff, exp_vec.double_indirect, self.ctx.val) - - def __neg__(self): - cdef nmod_mpoly res - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_neg(res.val, (self).val, res.ctx.val) - return res - - cdef _add_scalar_(self, arg): - cdef nmod_mpoly res - cdef ulong other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_add_ui(res.val, self.val, other, self.ctx.val) - return res - - cdef _sub_scalar_(self, arg): - cdef nmod_mpoly res - cdef ulong other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_sub_ui(res.val, self.val, other, self.ctx.val) - return res - - cdef _mul_scalar_(self, arg): - cdef nmod_mpoly res - cdef ulong other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_scalar_mul_ui(res.val, self.val, other, self.ctx.val) - return res - - cdef _pow_(self, arg): - cdef nmod_mpoly res - cdef fmpz other = arg - res = create_nmod_mpoly(self.ctx) - if nmod_mpoly_pow_fmpz(res.val, self.val, other.val, res.ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - cdef _add_mpoly_(self, arg): - cdef nmod_mpoly res, other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_add(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _sub_mpoly_(self, arg): - cdef nmod_mpoly res, other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_sub(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _mul_mpoly_(self, arg): - cdef nmod_mpoly res, other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_mul(res.val, self.val, other.val, res.ctx.val) - return res - - cdef _divmod_mpoly_(self, arg): - cdef nmod_mpoly quotient, remainder, other = arg - quotient = create_nmod_mpoly(self.ctx) - remainder = create_nmod_mpoly(self.ctx) - nmod_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return (quotient, remainder) - - cdef _floordiv_mpoly_(self, arg): - cdef nmod_mpoly quotient, other = arg - quotient = create_nmod_mpoly(self.ctx) - nmod_mpoly_div(quotient.val, self.val, other.val, self.ctx.val) - return quotient - - cdef _truediv_mpoly_(self, arg): - cdef nmod_mpoly quotient, other = arg - quotient = create_nmod_mpoly(self.ctx) - if nmod_mpoly_divides(quotient.val, self.val, other.val, self.ctx.val): - return quotient - else: - raise DomainError("nmod_mpoly division is not exact") - - cdef _mod_mpoly_(self, arg): - cdef nmod_mpoly quotient, remainder, other = arg - quotient = create_nmod_mpoly(self.ctx) - remainder = create_nmod_mpoly(self.ctx) - nmod_mpoly_divrem(quotient.val, remainder.val, self.val, other.val, self.ctx.val) - return remainder - - cdef _rsub_scalar_(self, arg): - cdef nmod_mpoly res - cdef ulong other = arg - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_sub_ui(res.val, self.val, other, self.ctx.val) - nmod_mpoly_neg(res.val, res.val, res.ctx.val) - return res - - cdef _rsub_mpoly_(self, arg): - return (arg)._sub_mpoly_(self) - - cdef _rdivmod_mpoly_(self, arg): - return (arg)._divmod_mpoly_(self) - - cdef _rfloordiv_mpoly_(self, arg): - return (arg)._floordiv_mpoly_(self) - - cdef _rtruediv_mpoly_(self, arg): - return (arg)._truediv_mpoly_(self) - - cdef _rmod_mpoly_(self, arg): - return (arg)._mod_mpoly_(self) - - cdef _iadd_scalar_(self, arg): - cdef ulong other = arg - nmod_mpoly_add_ui(self.val, self.val, other, self.ctx.val) - - cdef _isub_scalar_(self, arg): - cdef ulong other = arg - nmod_mpoly_sub_ui(self.val, self.val, other, self.ctx.val) - - cdef _imul_scalar_(self, arg): - cdef ulong other = arg - nmod_mpoly_scalar_mul_ui(self.val, self.val, other, self.ctx.val) - - cdef _iadd_mpoly_(self, arg): - cdef nmod_mpoly other = arg - nmod_mpoly_add(self.val, self.val, other.val, self.ctx.val) - - cdef _isub_mpoly_(self, arg): - cdef nmod_mpoly other = arg - nmod_mpoly_sub(self.val, self.val, other.val, self.ctx.val) - - cdef _imul_mpoly_(self, arg): - cdef nmod_mpoly other = arg - nmod_mpoly_mul(self.val, self.val, other.val, self.ctx.val) - - def __call__(self, *args) -> ulong: - cdef: - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs != nvars: - raise ValueError("number of generators does not match number of arguments") - - args = [self.ctx._any_as_scalar(x) for x in args] - cdef: - # Using sizeof(ulong) here breaks on 64 windows machines because of the ``ctypedef unsigned long ulong`` in - # flintlib/flint.pxd. Cython will inline this definition and then allocate the wrong amount of memory. - ulong *vals = libc.stdlib.malloc(nargs * SIZEOF_ULONG) - ulong res - if vals is NULL: - raise MemoryError("malloc returned a null pointer") # pragma: no cover - - try: - for i in range(nargs): - vals[i] = args[i] - res = nmod_mpoly_evaluate_all_ui(self.val, vals, self.ctx.val) - finally: - libc.stdlib.free(vals) - - return res - - def monoms(self): - """ - Return the exponent vectors of each term as a tuple of fmpz. - - >>> 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)] - - """ - cdef: - slong i, nvars = self.ctx.nvars() - fmpz_vec vec = fmpz_vec(nvars, double_indirect=True) - - res = [] - for i in range(len(self)): - nmod_mpoly_get_term_exp_fmpz(vec.double_indirect, self.val, i, self.ctx.val) - res.append(tuple(vec)) - - return res - - def coeffs(self): - """ - Return the coefficients of each term as a fmpz - - >>> 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.coeffs() - [4, 2, 3, 1] - - """ - return [nmod_mpoly_get_term_coeff_ui(self.val, i, self.ctx.val) for i in range(len(self))] - - def subs(self, dict_args) -> nmod_mpoly: - """ - Partial evaluate this polynomial with select constants. Keys must be generator names or generator indices, - all values must be fmpz. - - >>> 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.subs({"x1": 0}) - 2*x0 + 1 - - """ - cdef: - nmod_mpoly res - slong i - - args = tuple((self.ctx.variable_to_index(k), self.ctx._any_as_scalar(v)) for k, v in dict_args.items()) - for (_, v), old in zip(args, dict_args.values()): - if v is NotImplemented: - raise TypeError(f"cannot coerce {type(old)} to ulong") - - # Partial application with args in Z. We evaluate the polynomial one variable at a time - res = create_nmod_mpoly(self.ctx) - - nmod_mpoly_set(res.val, self.val, self.ctx.val) - for i, arg in args: - nmod_mpoly_evaluate_one_ui(res.val, res.val, i, arg, self.ctx.val) - return res - - def compose(self, *args, ctx=None) -> nmod_mpoly: - """ - Compose this polynomial with other nmod_mpolys. All arguments must share the same context, it may different - from this polynomials context. - - >>> ctx = nmod_mpoly_ctx.get(('x',), 11, 'lex') - >>> ctx1 = nmod_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 - - """ - cdef: - nmod_mpoly res - nmod_mpoly_ctx res_ctx - nmod_mpoly_vec C - slong nvars = self.ctx.nvars(), nargs = len(args) - - if nargs != nvars: - raise ValueError("number of generators does not match number of arguments") - elif self.ctx.nvars() == 0 and ctx is None: - raise ValueError("a context must be provided when composing a polynomial with no generators") - elif not all(typecheck(arg, nmod_mpoly) for arg in args): - raise TypeError("all arguments must be nmod_mpolys") - - if ctx is None: - res_ctx = ( args[0]).ctx - elif typecheck(ctx, nmod_mpoly_ctx): - res_ctx = ctx - else: - raise TypeError(f"provided context ({ctx}) is not a nmod_mpoly_ctx") - - if not all(( arg).ctx is res_ctx for arg in args): - raise IncompatibleContextError( - "all arguments must share the " + ("same" if ctx is not None else "provided") + " context" - ) - - C = nmod_mpoly_vec(args, res_ctx, double_indirect=True) - res = create_nmod_mpoly(res_ctx) - if nmod_mpoly_compose_nmod_mpoly(res.val, self.val, C.double_indirect, self.ctx.val, res_ctx.val) == 0: - raise ValueError("unreasonably large polynomial") # pragma: no cover - return res - - def context(self): - """ - Return the context object for this polynomials. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2}) - >>> ctx is p.context() - True - """ - return self.ctx - - def coefficient(self, slong i): - """ - Return the coefficient at index ``i``. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.coefficient(1) - 2 - """ - if not 0 <= i < nmod_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - else: - return nmod_mpoly_get_term_coeff_ui(self.val, i, self.ctx.val) - - def monomial(self, slong i): - """ - Return the exponent vector at index ``i`` as a tuple. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 1): 2, (1, 1): 3}) - >>> p.monomial(1) - (0, 1) - """ - cdef: - slong nvars = self.ctx.nvars() - - if not 0 <= i < nmod_mpoly_length(self.val, self.ctx.val): - raise IndexError("term index out of range") - res = fmpz_vec(nvars, double_indirect=True) - nmod_mpoly_get_term_exp_fmpz(res.double_indirect, self.val, i, self.ctx.val) - return tuple(res) - - def degrees(self): - """ - Return a dictionary of variable name to degree. - - >>> ctx = nmod_mpoly_ctx.get(('x', 4), 11, 'lex') - >>> p = sum(x**i for i, x in enumerate(ctx.gens())) - >>> p - x1 + x2^2 + x3^3 + 1 - >>> p.degrees() - (0, 1, 2, 3) - """ - cdef: - slong nvars = self.ctx.nvars() - - res = fmpz_vec(nvars, double_indirect=True) - nmod_mpoly_degrees_fmpz(res.double_indirect, self.val, self.ctx.val) - return tuple(res) - - def total_degree(self): - """ - Return the total degree. - - >>> ctx = nmod_mpoly_ctx.get(('x', 4), 11, 'lex') - >>> p = ctx.from_dict({(1, 0, 0, 0): 1, (0, 2, 0, 0): 2, (0, 0, 3, 0): 3}) - >>> p.total_degree() - 3 - """ - cdef fmpz res = fmpz() - nmod_mpoly_total_degree_fmpz(( res).val, self.val, self.ctx.val) - return res - - def leading_coefficient(self): - """ - Leading coefficient in the monomial ordering. - - >>> 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 - - """ - if nmod_mpoly_is_zero(self.val, self.ctx.val): - return nmod(0, self.ctx.modulus()) - else: - return nmod(self.coefficient(0), self.ctx.modulus()) - - def repr(self): - return f"{self.ctx}.from_dict({self.to_dict()})" - - def str(self): - cdef bytes s = nmod_mpoly_get_str_pretty(self.val, self.ctx.c_names, self.ctx.val) - res = s.decode().replace("+", " + ").replace("-", " - ") - if res.startswith(" - "): - res = "-" + res[3:] - return res - - def gcd(self, other): - """ - Return the gcd of self and other. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> g = ctx.from_dict({(0, 1): 2, (1, 0): 2}) - >>> (f * g).gcd(f) - x0*x1 + 3 - """ - cdef nmod_mpoly res - if not typecheck(other, nmod_mpoly): - raise TypeError("argument must be a nmod_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - elif not self.ctx.is_prime(): - raise DomainError("gcd with non-prime modulus is not supported") - res = create_nmod_mpoly(self.ctx) - nmod_mpoly_gcd(res.val, (self).val, (other).val, res.ctx.val) - return res - - def term_content(self): - """ - Return the GCD of the terms of ``self``. If ``self`` is zero, then the result will - be zero, otherwise it will be a monomial with positive coefficient. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> x0, x1 = ctx.gens() - >>> f = 3 * x0**2 * x1 + 6 * x0 * x1 - >>> f.term_content() - x0*x1 - """ - - cdef nmod_mpoly res = create_nmod_mpoly(self.ctx) - nmod_mpoly_term_content(res.val, self.val, self.ctx.val) - return res - - def resultant(self, other, var): - """ - Return the resultant of ``self`` and ``other`` with respect to variable ``var``. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> x0, x1 = ctx.gens() - >>> f = x0**2 * x1 + x0 * x1 - >>> g = x0 + x1 - >>> f.resultant(g, 'x1') - x0^3 + x0^2 - """ - cdef: - nmod_mpoly res - slong i - - if not typecheck(other, nmod_mpoly): - raise TypeError("argument must be a nmod_mpoly") - elif (self).ctx is not (other).ctx: - raise IncompatibleContextError(f"{(self).ctx} is not {(other).ctx}") - - i = self.ctx.variable_to_index(var) - res = create_nmod_mpoly(self.ctx) - if not nmod_mpoly_resultant(res.val, self.val, (other).val, i, self.ctx.val): - raise RuntimeError(f"failed to compute resultant with respect to {var}") - return res - - def discriminant(self, var): - """ - Return the discriminant of ``self`` with respect to variable ``var``. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> x0, x1 = ctx.gens() - >>> f = (x0 + x1)**2 + 1 - >>> f.discriminant('x1') - 7 - - """ - cdef: - nmod_mpoly res - slong i - - i = self.ctx.variable_to_index(var) - res = create_nmod_mpoly(self.ctx) - if not nmod_mpoly_discriminant(res.val, self.val, i, self.ctx.val): - raise RuntimeError(f"failed to compute discriminant with respect to {var}") - return res - - def sqrt(self): - """ - Return the square root of self. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> f = ctx.from_dict({(1, 1): 4, (0, 0): 1}) - >>> (f * f).sqrt() - 4*x0*x1 + 1 - """ - cdef nmod_mpoly res - if not self.ctx.is_prime(): - raise DomainError("square root with non-prime modulus is not supported") - - res = create_nmod_mpoly(self.ctx) - - if nmod_mpoly_sqrt(res.val, self.val, self.ctx.val): - return res - else: - raise DomainError("polynomial is not a perfect square") - - def factor(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = nmod_mpoly - >>> ctx = nmod_mpoly_ctx.get(('x', 'y', 'z'), 11, 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*z + 3*x + 3*z + 3", ctx) - >>> (p1 * p2).factor() - (6, [(z + 1, 1), (x + 1, 1), (x + 2, 1)]) - >>> (p2 * p1 * p2).factor() - (7, [(x + 2, 1), (z + 1, 2), (x + 1, 2)]) - """ - cdef: - nmod_mpoly_factor_t fac - fmpz c - nmod_mpoly u - - if not self.ctx.is_prime(): - raise DomainError("factorisation with non-prime modulus is not supported") - - nmod_mpoly_factor_init(fac, self.ctx.val) - if not nmod_mpoly_factor(fac, self.val, self.ctx.val): - raise RuntimeError("factorisation failed") - res = [0] * fac.num - - for i in range(fac.num): - u = create_nmod_mpoly(self.ctx) - nmod_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - constant = nmod(fac.constant, self.ctx.modulus()) - nmod_mpoly_factor_clear(fac, self.ctx.val) - - res.sort(key=_nmod_mpoly_sort_key) - - return constant, res - - def factor_squarefree(self): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the content of the coefficients and - factors is a list of (poly, exp) pairs. - - >>> Zm = nmod_mpoly - >>> ctx = nmod_mpoly_ctx.get(('x', 'y', 'z'), 11, 'lex') - >>> p1 = Zm("2*x + 4", ctx) - >>> p2 = Zm("3*x*y + 3*x + 3*y + 3", ctx) - >>> (p1 * p2).factor_squarefree() - (6, [(y + 1, 1), (x^2 + 3*x + 2, 1)]) - >>> (p1 * p2 * p1).factor_squarefree() - (1, [(y + 1, 1), (x + 1, 1), (x + 2, 2)]) - """ - cdef: - nmod_mpoly_factor_t fac - fmpz c - nmod_mpoly u - - if not self.ctx.is_prime(): - raise DomainError("factorisation with non-prime modulus is not supported") - - nmod_mpoly_factor_init(fac, self.ctx.val) - if not nmod_mpoly_factor_squarefree(fac, self.val, self.ctx.val): - raise RuntimeError("factorisation failed") - res = [0] * fac.num - - for i in range(fac.num): - u = create_nmod_mpoly(self.ctx) - nmod_mpoly_init(u.val, u.ctx.val) - nmod_mpoly_set((u).val, &fac.poly[i], self.ctx.val) - - c = fmpz.__new__(fmpz) - fmpz_set((c).val, &fac.exp[i]) - - res[i] = (u, int(c)) - - constant = nmod(fac.constant, self.ctx.modulus()) - nmod_mpoly_factor_clear(fac, self.ctx.val) - return constant, res - - def derivative(self, var): - """ - Return the derivative of this polynomial with respect to the provided variable. - The argument can either be the variable as a string, or the index of the - variable in the context. - - >>> ctx = nmod_mpoly_ctx.get(('x', 2), 11, 'lex') - >>> p = ctx.from_dict({(0, 3): 2, (2, 1): 3}) - >>> p - 3*x0^2*x1 + 2*x1^3 - >>> p.derivative("x0") - 6*x0*x1 - >>> p.derivative(1) - 3*x0^2 + 6*x1^2 - - """ - cdef: - nmod_mpoly res - slong i = self.ctx.variable_to_index(var) - - res = create_nmod_mpoly(self.ctx) - - nmod_mpoly_derivative(res.val, self.val, i, self.ctx.val) - return res - - def inflate(self, N: list[int]) -> nmod_mpoly: - """ - Compute the inflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^N)``. - - >>> ctx = nmod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x + y + 1 - >>> f.inflate([2, 3]) - x^2 + y^3 + 1 - """ - - cdef nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - elif any(n < 0 for n in N): - raise ValueError("all inflate strides must be non-negative") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - nmod_mpoly res = create_nmod_mpoly(self.ctx) - - nmod_mpoly_inflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - return res - - def deflate(self, N: list[int]) -> nmod_mpoly: - """ - Compute the deflation of ``self`` for a provided ``N``, that is return ``q`` - such that ``q(X) = p(X^(1/N))``. - - >>> ctx = nmod_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 - """ - cdef slong nvars = self.ctx.nvars() - - if nvars != len(N): - raise ValueError(f"expected list of length {nvars}, got {len(N)}") - - cdef: - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(N) - nmod_mpoly res = create_nmod_mpoly(self.ctx) - - nmod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - return res - - def deflation(self) -> tuple[nmod_mpoly, list[int]]: - """ - Compute the deflation of ``self``, that is ``p(X^(1/N))`` for maximal N. - - >>> ctx = nmod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x**2 * y**2 + x * y**2 - >>> q, N = f.deflation() - >>> q, N - (x^2*y + x*y, [1, 2]) - >>> q.inflate(N) == f - True - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - nmod_mpoly res = create_nmod_mpoly(self.ctx) - - nmod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - - for i in range(nvars): - stride[i] = shift[i].gcd(stride[i]) - shift[i] = 0 - - nmod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - - return res, list(stride) - - def deflation_monom(self) -> tuple[nmod_mpoly, list[int], nmod_mpoly]: - """ - Compute the exponent vector ``N`` and monomial ``m`` such that ``p(X^(1/N)) - = m * q(X^N)`` for maximal N. The returned monomial allows the undo-ing of the - deflation. - - >>> ctx = nmod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> fd, N, m = f.deflation_monom() - >>> fd, N, m - (x + y + 1, [2, 3], x*y) - >>> m * fd.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - nmod_mpoly res = create_nmod_mpoly(self.ctx) - nmod_mpoly monom = create_nmod_mpoly(self.ctx) - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - nmod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - nmod_mpoly_push_term_ui_ffmpz(monom.val, 1, fmpz_vec(shift).val, self.ctx.val) - nmod_mpoly_deflate(res.val, self.val, shift.val, stride.val, self.ctx.val) - - return res, list(stride), monom - - def deflation_index(self) -> tuple[list[int], list[int]]: - """ - Compute the exponent vectors ``N`` and ``I`` such that ``p(X^(1/N)) = X^I * - q(X^N)`` for maximal N. Importantly the deflation itself is not computed - here. The returned exponent vector ``I`` is the shift that was applied to the - exponents. It is the exponent vector of the monomial returned by - ``deflation_monom``. - - >>> ctx = nmod_mpoly_ctx.get(('x', 'y'), 11, 'lex') - >>> x, y = ctx.gens() - >>> f = x**3 * y + x * y**4 + x * y - >>> N, I = f.deflation_index() - >>> N, I - ([2, 3], [1, 1]) - >>> f_deflated = f.deflate(N) - >>> f_deflated - x + y + 1 - >>> m = ctx.term(exp_vec=I) - >>> m - x*y - >>> m * f_deflated.inflate(N) - x^3*y + x*y^4 + x*y - """ - cdef: - slong nvars = self.ctx.nvars() - fmpz_vec shift = fmpz_vec(nvars) - fmpz_vec stride = fmpz_vec(nvars) - - nmod_mpoly_deflation(shift.val, stride.val, self.val, self.ctx.val) - return list(stride), list(shift) - - cdef _compose_gens_(self, ctx, slong *mapping): - cdef nmod_mpoly res = create_nmod_mpoly(ctx) - nmod_mpoly_compose_nmod_mpoly_gen( - res.val, - self.val, - mapping, - self.ctx.val, - (ctx).val - ) - - return res - - -@cython.final -@cython.no_gc -cdef class _nmod_mpoly_sort_key: - cdef nmod_mpoly p - cdef ulong mult - - def __init__(self, tuple fac_m): - self.p = fac_m[0] - self.mult = fac_m[1] - - def __lt__(k1, _nmod_mpoly_sort_key k2): - cdef slong nterms - cdef tuple monom1, monom2 - cdef int coeff1, coeff2 - if k1.mult != k2.mult: - return k1.mult < k2.mult - nterms = min(k1.p.val.length, k2.p.val.length) - for i in range(nterms): - monom1 = k1.p.monomial(i) - monom2 = k2.p.monomial(i) - if monom1 != monom2: - return monom1 < monom2 - coeff1 = k1.p.coefficient(i) - coeff2 = k2.p.coefficient(i) - if coeff1 != coeff2: - return coeff1 < coeff2 - return k1.p.val.length < k2.p.val.length - - -cdef class nmod_mpoly_vec: - """ - A class representing a vector of nmod_mpolys. - """ - - def __cinit__(self, iterable_or_len, nmod_mpoly_ctx ctx, bint double_indirect = False): - if isinstance(iterable_or_len, int): - self.length = iterable_or_len - else: - self.length = len(iterable_or_len) - - self.ctx = ctx - - self.val = libc.stdlib.malloc(self.length * sizeof(nmod_mpoly_struct)) - for i in range(self.length): - nmod_mpoly_init(&self.val[i], self.ctx.val) - - if double_indirect: - self.double_indirect = libc.stdlib.malloc(self.length * sizeof(nmod_mpoly_struct *)) - if self.double_indirect is NULL: - raise MemoryError("malloc returned a null pointer") # pragma: no cover - - for i in range(self.length): - self.double_indirect[i] = &self.val[i] - else: - self.double_indirect = NULL - - def __init__(self, iterable_or_len, _, double_indirect: bool = False): - if not isinstance(iterable_or_len, int): - for i, x in enumerate(iterable_or_len): - self[i] = x - - def __dealloc__(self): - libc.stdlib.free(self.double_indirect) - for i in range(self.length): - nmod_mpoly_clear(&self.val[i], self.ctx.val) - libc.stdlib.free(self.val) - - def __getitem__(self, x): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - - cdef nmod_mpoly z = create_nmod_mpoly(self.ctx) - nmod_mpoly_set(z.val, &self.val[x], self.ctx.val) - return z - - def __setitem__(self, x, y): - if not isinstance(x, int): - raise TypeError("index is not integer") - elif not 0 <= x < self.length: - raise IndexError("index out of range") - elif not typecheck(y, nmod_mpoly): - raise TypeError("argument is not nmod_mpoly") - elif (y).ctx is not self.ctx: - raise IncompatibleContextError(f"{(y).ctx} is not {self.ctx}") - - nmod_mpoly_set(&self.val[x], (y).val, self.ctx.val) - - def __len__(self): - return self.val.length - - def __str__(self): - s = [None] * self.length - for i in range(self.length): - x = create_nmod_mpoly(self.ctx) - nmod_mpoly_set(x.val, &self.val[x], self.ctx.val) - s[i] = str(x) - return f"[{', '.join(s)}]" - - def __repr__(self): - return f"nmod_mpoly_vec({self}, ctx={self.ctx})" - - def __iter__(self): - cdef nmod_mpoly z - for i in range(self.length): - z = create_nmod_mpoly(self.ctx) - nmod_mpoly_set(z.val, &self.val[i], self.ctx.val) - yield z diff --git a/src/flint/types/nmod_poly.pxd b/src/flint/types/nmod_poly.pxd deleted file mode 100644 index fe872bde..00000000 --- a/src/flint/types/nmod_poly.pxd +++ /dev/null @@ -1,10 +0,0 @@ -from flint.flint_base.flint_base cimport flint_poly - -from flint.flintlib.functions.nmod_poly cimport nmod_poly_t -from flint.flintlib.types.flint cimport mp_limb_t - -cdef class nmod_poly(flint_poly): - cdef nmod_poly_t val - cpdef long length(self) - cpdef long degree(self) - cpdef mp_limb_t modulus(self) diff --git a/src/flint/types/nmod_poly.pyi b/src/flint/types/nmod_poly.pyi deleted file mode 100644 index b6574a03..00000000 --- a/src/flint/types/nmod_poly.pyi +++ /dev/null @@ -1,75 +0,0 @@ -from typing import overload, Iterator, Sequence -from flint.flint_base.flint_base import flint_poly -from flint.types.nmod import inmod, nmod -from flint.types.fmpz_poly import fmpz_poly - -inmod_poly = nmod_poly | fmpz_poly | inmod - -class nmod_poly(flint_poly[nmod]): - """Dense univariate polynomials over Z/nZ for word-size n.""" - - @overload - def __init__(self, val: nmod_poly) -> None: ... - @overload - def __init__(self, val: Sequence[inmod] | inmod_poly, mod: int) -> None: ... - def __len__(self) -> int: ... - def length(self) -> int: ... - def degree(self) -> int: ... - def modulus(self) -> int: ... - def __iter__(self) -> Iterator[nmod]: ... - def coeffs(self) -> list[nmod]: ... - def repr(self) -> str: ... - def __getitem__(self, i: int) -> nmod: ... - def __setitem__(self, i: int, x: inmod) -> None: ... - def __bool__(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_constant(self) -> bool: ... - def is_gen(self) -> bool: ... - def reverse(self, degree: int | None = None) -> nmod_poly: ... - def truncate(self, n: int) -> nmod_poly: ... - def leading_coefficient(self) -> nmod: ... - def inverse_series_trunc(self, n: int) -> nmod_poly: ... - def compose(self, other: inmod_poly) -> nmod_poly: ... - def compose_mod(self, other: inmod_poly, modulus: inmod_poly) -> nmod_poly: ... - @overload - def __call__(self, other: inmod) -> nmod: ... - @overload - def __call__(self, other: nmod_poly | fmpz_poly) -> nmod_poly: ... - def derivative(self) -> nmod_poly: ... - def integral(self) -> nmod_poly: ... - def __pos__(self) -> nmod_poly: ... - def __neg__(self) -> nmod_poly: ... - def __add__(self, other: inmod_poly) -> nmod_poly: ... - def __radd__(self, other: inmod_poly) -> nmod_poly: ... - def __sub__(self, other: inmod_poly) -> nmod_poly: ... - def __rsub__(self, other: inmod_poly) -> nmod_poly: ... - def __mul__(self, other: inmod_poly) -> nmod_poly: ... - def __rmul__(self, other: inmod_poly) -> nmod_poly: ... - def __truediv__(self, other: inmod_poly) -> nmod_poly: ... - def __rtruediv__(self, other: inmod_poly) -> nmod_poly: ... - def __floordiv__(self, other: inmod_poly) -> nmod_poly: ... - def __rfloordiv__(self, other: inmod_poly) -> nmod_poly: ... - def __mod__(self, other: inmod_poly) -> nmod_poly: ... - def __rmod__(self, other: inmod_poly) -> nmod_poly: ... - def __divmod__(self, other: inmod_poly) -> tuple[nmod_poly, nmod_poly]: ... - def __rdivmod__(self, other: inmod_poly) -> tuple[nmod_poly, nmod_poly]: ... - def left_shift(self, n: int) -> nmod_poly: ... - def right_shift(self, n: int) -> nmod_poly: ... - def mul_low(self, other: nmod_poly, n: int) -> nmod_poly: ... - def pow_trunc(self, e: int, n: int) -> nmod_poly: ... - def __pow__(self, other: int, mod: inmod_poly | None = None) -> nmod_poly: ... - def pow_mod( - self, e: int, modulus: inmod_poly, mod_rev_inv: inmod_poly | None = None - ) -> nmod_poly: ... - def gcd(self, other: inmod_poly) -> nmod_poly: ... - def discriminant(self) -> nmod: ... - def resultant(self, other: inmod_poly) -> nmod: ... - def xgcd(self, other: inmod_poly) -> tuple[nmod_poly, nmod_poly, nmod_poly]: ... - def factor( - self, algorithm: str | None = None - ) -> tuple[nmod, list[tuple[nmod_poly, int]]]: ... - def factor_squarefree(self) -> tuple[nmod, list[tuple[nmod_poly, int]]]: ... - def sqrt(self) -> nmod_poly: ... - def deflation(self) -> tuple[nmod_poly, int]: ... - def roots(self) -> list[tuple[nmod, int]]: ... diff --git a/src/flint/types/nmod_poly.pyx b/src/flint/types/nmod_poly.pyx deleted file mode 100644 index 9fc9bd1e..00000000 --- a/src/flint/types/nmod_poly.pyx +++ /dev/null @@ -1,992 +0,0 @@ -cimport cython -from cpython.list cimport PyList_Size as PyList_GET_SIZE -from flint.flint_base.flint_base cimport flint_poly -from flint.utils.typecheck cimport typecheck -from flint.types.fmpz cimport fmpz, any_as_fmpz -from flint.types.fmpz_poly cimport any_as_fmpz_poly -from flint.types.fmpz_poly cimport fmpz_poly -from flint.types.nmod cimport any_as_nmod -from flint.types.nmod cimport nmod - -from flint.flintlib.functions.nmod cimport nmod_init -from flint.flintlib.functions.nmod_poly cimport * -from flint.flintlib.functions.nmod_poly_factor cimport * -from flint.flintlib.functions.fmpz_poly cimport fmpz_poly_get_nmod_poly - -from flint.utils.flint_exceptions import DomainError - - -cdef any_as_nmod_poly(obj, nmod_t mod): - cdef nmod_poly r - cdef mp_limb_t v - # XXX: should check that modulus is the same here, and not all over the place - if typecheck(obj, nmod_poly): - return obj - if any_as_nmod(&v, obj, mod): - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init(r.val, mod.n) - nmod_poly_set_coeff_ui(r.val, 0, v) - return r - x = any_as_fmpz_poly(obj) - if x is not NotImplemented: - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init(r.val, mod.n) # XXX: create flint _nmod_poly_set_modulus for this? - fmpz_poly_get_nmod_poly(r.val, (x).val) - return r - return NotImplemented - -cdef nmod_poly_set_list(nmod_poly_t poly, list val): - cdef long i, n - cdef nmod_t mod - cdef mp_limb_t v - nmod_init(&mod, nmod_poly_modulus(poly)) # XXX - n = PyList_GET_SIZE(val) - nmod_poly_fit_length(poly, n) - for i from 0 <= i < n: - if any_as_nmod(&v, val[i], mod): - nmod_poly_set_coeff_ui(poly, i, v) - else: - raise TypeError("unsupported coefficient in list") - - -@cython.final -@cython.no_gc -cdef class _nmod_poly_sort_key: - cdef nmod_poly p - cdef ulong mult - cdef slong len - - def __init__(self, tuple fac_m): - self.p = fac_m[0] - self.len = nmod_poly_length(self.p.val) - self.mult = fac_m[1] - - def __lt__(k1, _nmod_poly_sort_key k2): - cdef slong i - cdef ulong c1, c2 - if k1.len != k2.len: - return k1.len < k2.len - elif k1.mult != k2.mult: - return k1.mult < k2.mult - i = k1.len - while i > 0: - i -= 1 - c1 = nmod_poly_get_coeff_ui(k1.p.val, i) - c2 = nmod_poly_get_coeff_ui(k2.p.val, i) - if c1 != c2: - return c1 < c2 - else: - return False - - -cdef class nmod_poly(flint_poly): - """ - The nmod_poly type represents dense univariate polynomials - over Z/nZ for word-size n. - - >>> from flint import ctx - >>> a = nmod_poly([5,1,10,14,8], 7) - >>> a - x^4 + 3*x^2 + x + 5 - >>> -a - 6*x^4 + 4*x^2 + 6*x + 2 - >>> ctx.pretty = False - >>> list(nmod_poly(list(range(3)), 2)) - [nmod(0, 2), nmod(1, 2)] - >>> nmod_poly([1, 2, 3], 23) ** 3 - nmod_poly([1, 6, 21, 21, 17, 8, 4], 23) - >>> divmod(nmod_poly([2,0,1,1,6],23), nmod_poly([3,5,7],23)) - (nmod_poly([4, 0, 14], 23), nmod_poly([13, 3], 23)) - >>> ctx.pretty = True - - """ - - # cdef nmod_poly_t val - - def __cinit__(self): - nmod_poly_init(self.val, 1) - - def __dealloc__(self): - nmod_poly_clear(self.val) - - def __init__(self, val=None, ulong mod=0): - cdef ulong m2 - cdef mp_limb_t v - if typecheck(val, nmod_poly): - m2 = nmod_poly_modulus((val).val) - if m2 != mod: - raise ValueError("different moduli!") - nmod_poly_init(self.val, m2) - nmod_poly_set(self.val, (val).val) - else: - if mod == 0: - raise ValueError("a nonzero modulus is required") - nmod_poly_init(self.val, mod) - if typecheck(val, fmpz_poly): - fmpz_poly_get_nmod_poly(self.val, (val).val) - elif typecheck(val, list): - nmod_poly_set_list(self.val, val) - elif any_as_nmod(&v, val, self.val.mod): - nmod_poly_fit_length(self.val, 1) - nmod_poly_set_coeff_ui(self.val, 0, v) - else: - raise TypeError("cannot create nmod_poly from input of type %s", type(val)) - - def __len__(self): - return nmod_poly_length(self.val) - - cpdef long length(self): - return nmod_poly_length(self.val) - - cpdef long degree(self): - return nmod_poly_degree(self.val) - - cpdef mp_limb_t modulus(self): - return nmod_poly_modulus(self.val) - - def __richcmp__(s, t, int op): - cdef bint res - if op != 2 and op != 3: - raise TypeError("nmod_polys cannot be ordered") - if typecheck(s, nmod_poly) and typecheck(t, nmod_poly): - if (s).val.mod.n != (t).val.mod.n: - res = False - else: - res = nmod_poly_equal((s).val, (t).val) - if op == 2: - return res - if op == 3: - return not res - else: - if not typecheck(s, nmod_poly): - s, t = t, s - try: - t = nmod_poly([t], (s).val.mod.n) - except TypeError: - pass - if typecheck(s, nmod_poly) and typecheck(t, nmod_poly): - if (s).val.mod.n != (t).val.mod.n: - res = False - else: - res = nmod_poly_equal((s).val, (t).val) - if op == 2: - return res - if op == 3: - return not res - return NotImplemented - - def __iter__(self): - cdef long i, n - n = self.length() - for i from 0 <= i < n: - yield self[i] - - def coeffs(self): - cdef long i, n - cdef list L - cdef mp_limb_t m - n = self.length() - m = self.modulus() - L = [nmod(0, m) for i in range(n)] # XXX: speed up - for i from 0 <= i < n: - ((L[i])).val = nmod_poly_get_coeff_ui(self.val, i) - return L - - def repr(self): - return "nmod_poly(%s, %s)" % ([int(c) for c in self.coeffs()], self.modulus()) - - def __getitem__(self, long i): - cdef nmod x - x = nmod(0, self.modulus()) - if i < 0: - return x - x.val = nmod_poly_get_coeff_ui(self.val, i) - return x - - def __setitem__(self, long i, x): - cdef mp_limb_t v - if i < 0: - raise ValueError("cannot assign to index < 0 of polynomial") - if any_as_nmod(&v, x, self.val.mod): - nmod_poly_set_coeff_ui(self.val, i, v) - else: - raise TypeError("cannot set element of type %s" % type(x)) - - def __bool__(self): - return not nmod_poly_is_zero(self.val) - - def is_zero(self): - """ - Returns True if this is the zero polynomial. - """ - return nmod_poly_is_zero(self.val) - - def is_one(self): - """ - Returns True if this polynomial is equal to 1. - """ - return nmod_poly_is_one(self.val) - - def is_constant(self): - """ - Returns True if this is a constant polynomial. - - >>> nmod_poly([0, 1], 3).is_constant() - False - >>> nmod_poly([1], 3).is_constant() - True - """ - return nmod_poly_degree(self.val) <= 0 - - def is_gen(self): - """ - Returns True if this polynomial is equal to the generator x. - - >>> x = nmod_poly([0, 1], 3) - >>> x - x - >>> x.is_gen() - True - >>> (2*x).is_gen() - False - """ - return nmod_poly_is_gen(self.val) - - def reverse(self, degree=None): - """ - Return a polynomial with the coefficients of this polynomial - reversed. - - If ``degree`` is not None, the output polynomial will be zero-padded - or truncated before being reversed. NOTE: degree must be non-negative. - - >>> f = nmod_poly([1,2,3,4,5], 163) - >>> f.reverse() - x^4 + 2*x^3 + 3*x^2 + 4*x + 5 - >>> f.reverse(degree=1) - x + 2 - >>> f.reverse(degree=100) - x^100 + 2*x^99 + 3*x^98 + 4*x^97 + 5*x^96 - """ - cdef nmod_poly res - cdef slong d - - if degree is not None: - d = degree - if d != degree or d < 0: - raise ValueError(f"degree argument must be a non-negative integer, got {degree}") - length = d + 1 - else: - length = nmod_poly_length(self.val) - - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_reverse(res.val, self.val, length) - return res - - def truncate(self, slong n): - r""" - Notionally truncate the polynomial to have length ``n``. If - ``n`` is larger than the length of the input, then a copy of ``self`` is - returned. If ``n`` is not positive, then the zero polynomial - is returned. - - Effectively returns this polynomial :math:`\mod x^n`. - - >>> f = nmod_poly([1,2,3], 65537) - >>> f.truncate(3) == f - True - >>> f.truncate(2) - 2*x + 1 - >>> f.truncate(1) - 1 - >>> f.truncate(0) - 0 - >>> f.truncate(-1) - 0 - - """ - cdef nmod_poly res - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - - length = nmod_poly_length(self.val) - if n <= 0: # return zero - return res - elif n > length: # do nothing - nmod_poly_set(res.val, self.val) - else: - nmod_poly_set_trunc(res.val, self.val, n) - - return res - - def leading_coefficient(self): - """ - Return the leading coefficient of this polynomial. - - >>> f = nmod_poly([123, 129, 63, 14, 51, 76, 133], 163) - >>> f.leading_coefficient() - 133 - """ - cdef ulong cu - cdef slong d - cdef nmod c - - d = self.degree() - if d < 0: - cu = 0 - else: - cu = nmod_poly_get_coeff_ui(self.val, d) - - c = nmod.__new__(nmod) - c.mod = self.val.mod - c.val = cu - - return c - - def inverse_series_trunc(self, slong n): - """ - Returns the inverse of ``self`` modulo `x^n`. Assumes the leading - coefficient of the polynomial is invertible. - - >>> f = nmod_poly([123, 129, 63, 14, 51, 76, 133], 163) - >>> f.inverse_series_trunc(3) - 159*x^2 + 151*x + 110 - >>> f.inverse_series_trunc(4) - 23*x^3 + 159*x^2 + 151*x + 110 - >>> f.inverse_series_trunc(5) - 45*x^4 + 23*x^3 + 159*x^2 + 151*x + 110 - """ - if n <= 0: - raise ValueError(f"n = {n} must be positive") - - if self.is_zero(): - raise ValueError("cannot invert the zero element") - - cdef nmod_poly res - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_inv_series(res.val, self.val, n) - return res - - def compose(self, other): - """ - Returns the composition of two polynomials - - To be precise about the order of composition, given ``self``, and ``other`` - by `f(x)`, `g(x)`, returns `f(g(x))`. - - >>> f = nmod_poly([1,2,3], 163) - >>> g = nmod_poly([0,0,1], 163) - >>> f.compose(g) - 3*x^4 + 2*x^2 + 1 - >>> g.compose(f) - 9*x^4 + 12*x^3 + 10*x^2 + 4*x + 1 - """ - cdef nmod_poly res - other = any_as_nmod_poly(other, (self).val.mod) - if other is NotImplemented: - raise TypeError("cannot convert input to nmod_poly") - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_compose(res.val, self.val, (other).val) - return res - - def compose_mod(self, other, modulus): - r""" - Returns the composition of two polynomials modulo a third. - - To be precise about the order of composition, given ``self``, and ``other`` - and ``modulus`` by `f(x)`, `g(x)` and `h(x)`, returns `f(g(x)) \mod h(x)`. - We require that `h(x)` is non-zero. - - >>> f = nmod_poly([1,2,3,4,5], 163) - >>> g = nmod_poly([3,2,1], 163) - >>> h = nmod_poly([1,0,1,0,1], 163) - >>> f.compose_mod(g, h) - 63*x^3 + 100*x^2 + 17*x + 63 - >>> g.compose_mod(f, h) - 147*x^3 + 159*x^2 + 4*x + 7 - """ - cdef nmod_poly res - g = any_as_nmod_poly(other, self.val.mod) - if g is NotImplemented: - raise TypeError(f"cannot convert other = {other} to nmod_poly") - - h = any_as_nmod_poly(modulus, self.val.mod) - if h is NotImplemented: - raise TypeError(f"cannot convert modulus = {modulus} to nmod_poly") - - if modulus.is_zero(): - raise ZeroDivisionError("cannot reduce modulo zero") - - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_compose_mod(res.val, self.val, (other).val, (modulus).val) - return res - - def __call__(self, other): - cdef mp_limb_t c - if any_as_nmod(&c, other, self.val.mod): - v = nmod(0, self.modulus()) - (v).val = nmod_poly_evaluate_nmod(self.val, c) - return v - t = any_as_nmod_poly(other, self.val.mod) - if t is not NotImplemented: - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv((r).val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_compose((r).val, self.val, (t).val) - return r - raise TypeError("cannot call nmod_poly with input of type %s", type(other)) - - def derivative(self): - cdef nmod_poly res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_derivative(res.val, self.val) - return res - - def integral(self): - cdef nmod_poly res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_integral(res.val, self.val) - return res - - def __pos__(self): - return self - - def __neg__(self): - cdef nmod_poly r = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(r.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_neg(r.val, self.val) - return r - - def _add_(s, t): - cdef nmod_poly r - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - if (s).val.mod.n != (t).val.mod.n: - raise ValueError("cannot add nmod_polys with different moduli") - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(r.val, (t).val.mod.n, (t).val.mod.ninv) - nmod_poly_add(r.val, (s).val, (t).val) - return r - - def __add__(s, t): - return s._add_(t) - - def __radd__(s, t): - return s._add_(t) - - def _sub_(s, t): - cdef nmod_poly r - if (s).val.mod.n != (t).val.mod.n: - raise ValueError("cannot subtract nmod_polys with different moduli") - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(r.val, (t).val.mod.n, (t).val.mod.ninv) - nmod_poly_sub(r.val, (s).val, (t).val) - return r - - def __sub__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - return s._sub_(t) - - def __rsub__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - return t._sub_(s) - - def _mul_(s, t): - cdef nmod_poly r - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - if (s).val.mod.n != (t).val.mod.n: - raise ValueError("cannot multiply nmod_polys with different moduli") - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(r.val, (t).val.mod.n, (t).val.mod.ninv) - nmod_poly_mul(r.val, (s).val, (t).val) - return r - - def __mul__(s, t): - return s._mul_(t) - - def __rmul__(s, t): - return s._mul_(t) - - def __truediv__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - res, r = s._divmod_(t) - if not nmod_poly_is_zero((r).val): - raise DomainError("nmod_poly inexact division") - return res - - def __rtruediv__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - res, r = t._divmod_(s) - if not nmod_poly_is_zero((r).val): - raise DomainError("nmod_poly inexact division") - return res - - def _floordiv_(s, t): - cdef nmod_poly r - if (s).val.mod.n != (t).val.mod.n: - raise ValueError("cannot divide nmod_polys with different moduli") - if nmod_poly_is_zero((t).val): - raise ZeroDivisionError("polynomial division by zero") - r = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(r.val, (t).val.mod.n, (t).val.mod.ninv) - nmod_poly_div(r.val, (s).val, (t).val) - return r - - def __floordiv__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - return s._floordiv_(t) - - def __rfloordiv__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - return t._floordiv_(s) - - def _divmod_(s, t): - cdef nmod_poly P, Q - if (s).val.mod.n != (t).val.mod.n: - raise ValueError("cannot divide nmod_polys with different moduli") - if nmod_poly_is_zero((t).val): - raise ZeroDivisionError("polynomial division by zero") - P = nmod_poly.__new__(nmod_poly) - Q = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(P.val, (t).val.mod.n, (t).val.mod.ninv) - nmod_poly_init_preinv(Q.val, (t).val.mod.n, (t).val.mod.ninv) - nmod_poly_divrem(P.val, Q.val, (s).val, (t).val) - return P, Q - - def __divmod__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - return s._divmod_(t) - - def __rdivmod__(s, t): - t = any_as_nmod_poly(t, (s).val.mod) - if t is NotImplemented: - return t - return t._divmod_(s) - - def __mod__(s, t): - return divmod(s, t)[1] # XXX - - def __rmod__(s, t): - return divmod(t, s)[1] # XXX - - def left_shift(self, slong n): - """ - Returns ``self`` shifted left by ``n`` coefficients by inserting - zero coefficients. This is equivalent to multiplying the polynomial - by x^n - - >>> f = nmod_poly([1,2,3], 99991) - >>> 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 - - """ - cdef nmod_poly res - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - nmod_poly_shift_left(res.val, self.val, n) - else: # do nothing, just copy self - nmod_poly_set(res.val, self.val) - - return res - - def right_shift(self, slong n): - """ - Returns ``self`` shifted right by ``n`` coefficients. - This is equivalent to the floor division of the polynomial - by x^n - - >>> f = nmod_poly([1,2,3], 99991) - >>> f.right_shift(0) - 3*x^2 + 2*x + 1 - >>> f.right_shift(1) - 3*x + 2 - >>> f.right_shift(4) - 0 - """ - cdef nmod_poly res - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - - if n < 0: - raise ValueError("Value must be shifted by a non-negative integer") - if n > 0: - nmod_poly_shift_right(res.val, self.val, n) - else: # do nothing, just copy self - nmod_poly_set(res.val, self.val) - - return res - - def __pow__(nmod_poly self, exp, mod=None): - cdef nmod_poly res - if mod is not None: - return self.pow_mod(exp, mod) - if exp < 0: - self = 1 / self - exp = -exp - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, (self).val.mod.n, (self).val.mod.ninv) - nmod_poly_pow(res.val, self.val, exp) - return res - - def pow_mod(self, e, modulus, mod_rev_inv=None): - r""" - Returns ``self`` raised to the power ``e`` modulo ``modulus``: - :math:`f^e \mod g`/ - - ``mod_rev_inv`` is the inverse of the reverse of the modulus, - precomputing it and passing it to ``pow_mod()`` can optimise - powering of polynomials with large exponents. - - >>> x = nmod_poly([0,1], 163) - >>> f = 30*x**6 + 104*x**5 + 76*x**4 + 33*x**3 + 70*x**2 + 44*x + 65 - >>> g = 43*x**6 + 91*x**5 + 77*x**4 + 113*x**3 + 71*x**2 + 132*x + 60 - >>> mod = x**4 + 93*x**3 + 78*x**2 + 72*x + 149 - >>> - >>> f.pow_mod(123, mod) - 3*x^3 + 25*x^2 + 115*x + 161 - >>> f.pow_mod(2**64, mod) - 52*x^3 + 96*x^2 + 136*x + 9 - >>> mod_rev_inv = mod.reverse().inverse_series_trunc(4) - >>> f.pow_mod(2**64, mod, mod_rev_inv) - 52*x^3 + 96*x^2 + 136*x + 9 - """ - cdef nmod_poly res - - if e < 0: - raise ValueError("Exponent must be non-negative") - - modulus = any_as_nmod_poly(modulus, (self).val.mod) - if modulus is NotImplemented: - raise TypeError("cannot convert input to nmod_poly") - - # Output polynomial - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - - # For small exponents, use a simple binary exponentiation method - if e.bit_length() < 32: - nmod_poly_powmod_ui_binexp( - res.val, self.val, e, (modulus).val - ) - return res - - # For larger exponents we need to cast e to an fmpz first - e_fmpz = any_as_fmpz(e) - if e_fmpz is NotImplemented: - raise TypeError(f"exponent cannot be cast to an fmpz type: {e}") - - # To optimise powering, we precompute the inverse of the reverse of the modulus - if mod_rev_inv is not None: - mod_rev_inv = any_as_nmod_poly(mod_rev_inv, (self).val.mod) - if mod_rev_inv is NotImplemented: - raise TypeError(f"Cannot interpret {mod_rev_inv} as a polynomial") - else: - mod_rev_inv = modulus.reverse().inverse_series_trunc(modulus.length()) - - # Use windowed exponentiation optimisation when self = x - if self.is_gen(): - nmod_poly_powmod_x_fmpz_preinv( - res.val, (e_fmpz).val, (modulus).val, (mod_rev_inv).val - ) - return res - - # Otherwise using binary exponentiation for all other inputs - nmod_poly_powmod_fmpz_binexp_preinv( - res.val, self.val, (e_fmpz).val, (modulus).val, (mod_rev_inv).val - ) - return res - - def mul_low(self, other, slong n): - r""" - Returns the lowest ``n`` coefficients of the multiplication of ``self`` with ``other`` - - Equivalent to computing `f(x) \cdot g(x) \mod x^n` - - >>> f = nmod_poly([2,3,5,7,11], 163) - >>> g = nmod_poly([1,2,4,8,16], 163) - >>> f.mul_low(g, 5) - 101*x^4 + 45*x^3 + 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 3) - 19*x^2 + 7*x + 2 - >>> f.mul_low(g, 1) - 2 - """ - # Only allow multiplication with other nmod_poly - if not typecheck(other, nmod_poly): - raise TypeError("other polynomial must be of type nmod_poly") - - if (self).val.mod.n != (other).val.mod.n: - raise ValueError("cannot multiply nmod_polys with different moduli") - - cdef nmod_poly res = nmod_poly.__new__(nmod_poly) - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_mullow(res.val, self.val, (other).val, n) - return res - - def pow_trunc(self, e, slong n): - r""" - Returns ``self`` raised to the power ``e`` modulo `x^n`: - :math:`f^e \mod x^n`/ - - >>> f = nmod_poly([65, 44, 70, 33, 76, 104, 30], 163) - >>> x = nmod_poly([0, 1], 163) - >>> f.pow_trunc(2**20, 30) == pow(f, 2**20, x**30) - True - >>> f.pow_trunc(2**20, 5) - 132*x^4 + 113*x^3 + 36*x^2 + 48*x + 6 - >>> f.pow_trunc(5**25, 5) - 147*x^4 + 98*x^3 + 95*x^2 + 33*x + 126 - """ - if e < 0: - raise ValueError("Exponent must be non-negative") - - cdef nmod_poly res, tmp - cdef slong e_c - - try: - e_c = e - except OverflowError: - # Exponent does not fit slong - res = nmod_poly.__new__(nmod_poly) - tmp = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_init_preinv(tmp.val, self.val.mod.n, self.val.mod.ninv) - ebytes = e.to_bytes((e.bit_length() + 15) // 16 * 2, "big") - nmod_poly_pow_trunc(res.val, self.val, ebytes[0] * 256 + ebytes[1], n) - for i in range(2, len(ebytes), 2): - nmod_poly_pow_trunc(res.val, res.val, 1 << 16, n) - nmod_poly_pow_trunc(tmp.val, self.val, ebytes[i] * 256 + ebytes[i+1], n) - nmod_poly_mullow(res.val, res.val, tmp.val, n) - return res - - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_pow_trunc(res.val, self.val, e_c, n) - return res - - def gcd(self, other): - """ - Returns the monic greatest common divisor of self and other. - - >>> A = nmod_poly([1,2,3,4], 7); B = nmod_poly([4,1,5], 7) - >>> (A * B).gcd(B) * 5 - 5*x^2 + x + 4 - - """ - cdef nmod_poly res - other = any_as_nmod_poly(other, (self).val.mod) - if other is NotImplemented: - raise TypeError("cannot convert input to nmod_poly") - if self.val.mod.n != (other).val.mod.n: - raise ValueError("moduli must be the same") - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - nmod_poly_gcd(res.val, self.val, (other).val) - return res - - def discriminant(self): - """ - Return the discriminant of ``self``. - - >>> f = nmod_poly([1, 2, 3, 4, 5, 6], 65537) - >>> f.discriminant() - 54177 - >>> f = nmod_poly([1, 3, 5, 7, 9, 11, 13], 65537) - >>> f.discriminant() - 44859 - - """ - cdef nmod res = nmod(0, self.modulus()) - res.val = nmod_poly_discriminant(self.val) - return res - - def resultant(self, other): - """ - Returns the resultant of *self* and *other*. - - >>> f = nmod_poly([1, 2, 3], 3) - >>> g = nmod_poly([1, 0, 1], 3) - >>> f.resultant(f) - 0 - >>> f.resultant(g) - 2 - - """ - cdef ulong res - - mod = any_as_fmpz(self.val.mod.n) - if not mod.is_prime(): - raise ValueError("cannot compute nmod_poly resultants with composite moduli") - - other = any_as_nmod_poly(other, (self).val.mod) - if other is NotImplemented: - raise TypeError("cannot convert input to nmod_poly") - - res = nmod_poly_resultant(self.val, (other).val) - return res - - def xgcd(self, other): - cdef nmod_poly res1, res2, res3 - other = any_as_nmod_poly(other, (self).val.mod) - if other is NotImplemented: - raise TypeError("cannot convert input to fmpq_poly") - res1 = nmod_poly.__new__(nmod_poly) - res2 = nmod_poly.__new__(nmod_poly) - res3 = nmod_poly.__new__(nmod_poly) - nmod_poly_init(res1.val, (self).val.mod.n) - nmod_poly_init(res2.val, (self).val.mod.n) - nmod_poly_init(res3.val, (self).val.mod.n) - nmod_poly_xgcd(res1.val, res2.val, res3.val, self.val, (other).val) - return (res1, res2, res3) - - def factor(self, algorithm=None): - """ - Factors self into irreducible factors, returning a tuple - (c, factors) where c is the leading coefficient and - factors is a list of (poly, exp) pairs with all polynomials - monic. - - >>> nmod_poly(list(range(10)), 3).factor() - (2, [(x, 1), (x + 2, 7)]) - >>> nmod_poly(list(range(10)), 19).factor() - (9, [(x, 1), (x^4 + 7*x^3 + 12*x^2 + 15*x + 12, 1), (x^4 + 15*x^3 + 2*x^2 + 7*x + 3, 1)]) - >>> nmod_poly(list(range(10)), 53).factor() - (9, [(x, 1), (x^8 + 48*x^7 + 42*x^6 + 36*x^5 + 30*x^4 + 24*x^3 + 18*x^2 + 12*x + 6, 1)]) - - Algorithm can be None (default), 'berlekamp', or - 'cantor-zassenhaus'. - - >>> nmod_poly([3,2,1,2,3], 7).factor(algorithm='berlekamp') - (3, [(x + 2, 1), (x + 4, 1), (x^2 + 4*x + 1, 1)]) - >>> nmod_poly([3,2,1,2,3], 7).factor(algorithm='cantor-zassenhaus') - (3, [(x + 2, 1), (x + 4, 1), (x^2 + 4*x + 1, 1)]) - - """ - if algorithm is None: - algorithm = 'irreducible' - elif algorithm not in ('berlekamp', 'cantor-zassenhaus'): - raise ValueError(f"unknown factorization algorithm: {algorithm}") - return self._factor(algorithm) - - def factor_squarefree(self): - """ - Factors *self* into square-free polynomials. Returns (*c*, *factors*) - where *c* is the leading coefficient and *factors* is a list of - (*poly*, *exp*). - - >>> x = nmod_poly([0, 1], 7) - >>> p = x**2 * (x/2 - 1)**2 * (x + 1)**3 - >>> p - 2*x^7 + 5*x^6 + 4*x^5 + 2*x^4 + 2*x^3 + x^2 - >>> p.factor_squarefree() - (2, [(x + 1, 3), (x^2 + 5*x, 2)]) - >>> p.factor() - (2, [(x, 2), (x + 5, 2), (x + 1, 3)]) - - """ - return self._factor('squarefree') - - def _factor(self, factor_type): - cdef nmod_poly_factor_t fac - cdef mp_limb_t lead - cdef int i - - nmod_poly_factor_init(fac) - - if factor_type == 'berlekamp': - lead = nmod_poly_factor_with_berlekamp(fac, self.val) - elif factor_type == 'cantor-zassenhaus': - lead = nmod_poly_factor_with_cantor_zassenhaus(fac, self.val) - elif factor_type == 'irreducible': - lead = nmod_poly_factor(fac, self.val) - elif factor_type == 'squarefree': - nmod_poly_factor_squarefree(fac, self.val) - lead = (self.leading_coefficient()).val - else: - assert False - - res = [None] * fac.num - for 0 <= i < fac.num: - u = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv((u).val, - (self).val.mod.n, (self).val.mod.ninv) - nmod_poly_set((u).val, &fac.p[i]) - exp = fac.exp[i] - res[i] = (u, exp) - - res.sort(key=_nmod_poly_sort_key) - - c = nmod.__new__(nmod) - (c).mod = self.val.mod - (c).val = lead - - nmod_poly_factor_clear(fac) - - return c, res - - def sqrt(nmod_poly self): - """Return exact square root or ``None``. """ - cdef nmod_poly res - res = nmod_poly.__new__(nmod_poly) - nmod_poly_init_preinv(res.val, self.val.mod.n, self.val.mod.ninv) - if nmod_poly_sqrt(res.val, self.val): - return res - else: - raise DomainError(f"Cannot compute square root of {self}") - - def deflation(self): - cdef nmod_poly v - cdef ulong n - if nmod_poly_is_zero(self.val): - return self, 1 - n = nmod_poly_deflation(self.val) - if n == 1: - return self, int(n) - else: - v = nmod_poly.__new__(nmod_poly) - nmod_poly_init(v.val, self.val.mod.n) - nmod_poly_deflate(v.val, self.val, n) - return v, int(n) - - def real_roots(self): - r""" - This method is not implemented for polynomials in - :math:`(\mathbb{Z}/N\mathbb{Z})[X]` - """ - raise DomainError("Cannot compute real roots for polynomials over integers modulo N") - - def complex_roots(self): - r""" - This method is not implemented for polynomials in - :math:`(\mathbb{Z}/N\mathbb{Z})[X]` - """ - raise DomainError("Cannot compute complex roots for polynomials over integers modulo N") diff --git a/src/flint/types/nmod_series.pxd b/src/flint/types/nmod_series.pxd deleted file mode 100644 index 613a97c9..00000000 --- a/src/flint/types/nmod_series.pxd +++ /dev/null @@ -1,4 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series - -cdef class nmod_series(flint_series): - pass diff --git a/src/flint/types/nmod_series.pyx b/src/flint/types/nmod_series.pyx deleted file mode 100644 index 613a97c9..00000000 --- a/src/flint/types/nmod_series.pyx +++ /dev/null @@ -1,4 +0,0 @@ -from flint.flint_base.flint_base cimport flint_series - -cdef class nmod_series(flint_series): - pass diff --git a/src/flint/typing.py b/src/flint/typing.py deleted file mode 100644 index 94c4edf3..00000000 --- a/src/flint/typing.py +++ /dev/null @@ -1,322 +0,0 @@ -# -# -# -from __future__ import annotations - -from typing import ( - TYPE_CHECKING, - Protocol, - TypeVar, - Iterator, - Iterable, - Any, - Mapping, - Sequence, - overload, -) - -if TYPE_CHECKING: - from typing import Self - -from .flint_base.flint_base import ( - flint_elem, - flint_scalar, - flint_poly, - flint_mpoly, - flint_mpoly_context, - flint_series, - Ordering, -) - -from flint.types.fmpz import fmpz - -__all__ = [ - # Abstract base classes - "flint_elem", - "flint_scalar", - "flint_poly", - "flint_mpoly", - "flint_mpoly_context", - "flint_series", - - # Protocols - "elem_p", - "scalar_p", - "poly_p", - # "series_p", - "mpoly_p", - "mpoly_context_p", - - # Types - "Ordering", - "fmpz", - "ifmpz", -] - - -_str = str - - -ifmpz = fmpz | int - - -class elem_p(Protocol): - """FLINT element Protocol.""" - def str(self) -> _str: ... - def repr(self) -> _str: ... - - -class scalar_p(elem_p, Protocol): - """FLINT scalar Protocol.""" - def is_zero(self) -> bool: ... - def __pos__(self) -> Self: ... - def __neg__(self) -> Self: ... - def __add__(self, other: Self | int, /) -> Self: ... - def __radd__(self, other: int, /) -> Self: ... - def __sub__(self, other: Self | int, /) -> Self: ... - def __rsub__(self, other: int, /) -> Self: ... - def __mul__(self, other: Self | int, /) -> Self: ... - def __rmul__(self, other: int, /) -> Self: ... - def __truediv__(self, other: Self | int, /) -> Self: ... - def __rtruediv__(self, other: int, /) -> Self: ... - def __pow__(self, other: int, /) -> Self: ... - def __rpow__(self, other: int, /) -> Self: ... - - -_Tscalar = TypeVar("_Tscalar", bound=scalar_p) -_Tscalar_contra = TypeVar("_Tscalar_contra", bound=scalar_p, contravariant=True) - - -class poly_p(elem_p, Protocol[_Tscalar]): - """FLINT univariate polynomial Protocol.""" - def str( - self, ascending: bool = False, var: str = "x", *args: Any, **kwargs: Any - ) -> str: ... - def __iter__(self) -> Iterator[_Tscalar]: ... - def __getitem__(self, index: int, /) -> _Tscalar: ... - def __setitem__(self, index: int, value: _Tscalar | int, /) -> None: ... - def __len__(self) -> int: ... - def length(self) -> int: ... - def degree(self) -> int: ... - def coeffs(self) -> list[_Tscalar]: ... - @overload - def __call__(self, other: _Tscalar | ifmpz, /) -> _Tscalar: ... - @overload - def __call__(self, other: Self, /) -> Self: ... # pyright: ignore[reportOverlappingOverload] - - def __pos__(self) -> Self: ... - def __neg__(self) -> Self: ... - def __add__(self, other: _Tscalar | ifmpz | Self, /) -> Self: ... - def __radd__(self, other: _Tscalar | ifmpz, /) -> Self: ... - def __sub__(self, other: _Tscalar | ifmpz | Self, /) -> Self: ... - def __rsub__(self, other: _Tscalar | ifmpz, /) -> Self: ... - def __mul__(self, other: _Tscalar | ifmpz | Self, /) -> Self: ... - def __rmul__(self, other: _Tscalar | ifmpz, /) -> Self: ... - def __truediv__(self, other: _Tscalar | ifmpz | Self, /) -> Self: ... - def __rtruediv__(self, other: _Tscalar | ifmpz, /) -> Self: ... - def __floordiv__(self, other: _Tscalar | ifmpz | Self, /) -> Self: ... - def __rfloordiv__(self, other: _Tscalar | ifmpz, /) -> Self: ... - def __mod__(self, other: _Tscalar | ifmpz | Self, /) -> Self: ... - def __rmod__(self, other: _Tscalar | ifmpz, /) -> Self: ... - def __divmod__(self, other: _Tscalar | ifmpz | Self, /) -> tuple[Self, Self]: ... - def __rdivmod__(self, other: _Tscalar | ifmpz, /) -> tuple[Self, Self]: ... - def __pow__(self, other: int, /) -> Self: ... - - def left_shift(self, other: int, /) -> Self: ... - def right_shift(self, other: int, /) -> Self: ... - def truncate(self, n: int, /) -> Self: ... - - def is_zero(self) -> bool: ... - def is_one(self) -> bool: ... - def is_constant(self) -> bool: ... - def is_gen(self) -> bool: ... - def roots(self) -> list[tuple[_Tscalar, int]]: ... - # Should be list[arb]: - def real_roots(self) -> list[Any]: ... - # Should be list[acb]: - def complex_roots(self) -> list[Any]: ... - def derivative(self) -> Self: ... - - -class epoly_p(poly_p[_Tscalar], Protocol): - """FLINT exact univariate polynomial Protocol.""" - def sqrt(self) -> Self: ... - def gcd(self, other: Self | _Tscalar, /) -> Self: ... - def factor(self) -> tuple[_Tscalar, list[tuple[Self, int]]]: ... - def factor_squarefree(self) -> tuple[_Tscalar, list[tuple[Self, int]]]: ... - def deflation(self) -> tuple[Self, int]: ... - def mul_low(self, other: Self, n: int) -> Self: ... - def pow_trunc(self, e: int, n: int) -> Self: ... - - -class _series_p(elem_p, Protocol[_Tscalar]): - """FLINT univariate power series.""" - - def __iter__(self) -> Iterator[_Tscalar]: ... - def coeffs(self) -> list[_Tscalar]: ... - - -class mpoly_p(elem_p, Protocol[_Tscalar]): - def __init__( - self, - val: Self - | _Tscalar - | int - | Mapping[tuple[int, ...], _Tscalar | int] - | str = 0, - ctx: Any | None = None, - ) -> None: ... - def str(self) -> _str: ... - def repr(self) -> _str: ... - def context(self) -> mpoly_context_p[Self, _Tscalar]: ... - def degrees(self) -> tuple[int, ...]: ... - def total_degree(self) -> int: ... - def leading_coefficient(self) -> _Tscalar: ... - def to_dict(self) -> dict[tuple[int, ...], _Tscalar]: ... - def is_one(self) -> bool: ... - def is_zero(self) -> bool: ... - def is_constant(self) -> bool: ... - def __len__(self) -> int: ... - def __getitem__(self, index: tuple[int, ...]) -> _Tscalar: ... - def __setitem__( - self, index: tuple[int, ...], coeff: _Tscalar | int - ) -> None: ... - def __iter__(self) -> Iterable[tuple[int, ...]]: ... - def __contains__(self, index: tuple[int, ...]) -> bool: ... - def coefficient(self, i: int) -> _Tscalar: ... - def monomial(self, i: int) -> tuple[int, ...]: ... - def terms(self) -> Iterable[tuple[tuple[int, ...], _Tscalar]]: ... - def monoms(self) -> list[tuple[int, ...]]: ... - def coeffs(self) -> list[_Tscalar]: ... - def __pos__(self) -> Self: ... - def __neg__(self) -> Self: ... - def __add__(self, other: Self | _Tscalar | int) -> Self: ... - def __radd__(self, other: _Tscalar | int) -> Self: ... - def __sub__(self, other: Self | _Tscalar | int) -> Self: ... - def __rsub__(self, other: _Tscalar | int) -> Self: ... - def __mul__(self, other: Self | _Tscalar | int) -> Self: ... - def __rmul__(self, other: _Tscalar | int) -> Self: ... - def __truediv__(self, other: Self | _Tscalar | int) -> Self: ... - def __rtruediv__(self, other: _Tscalar | int) -> Self: ... - def __floordiv__(self, other: Self | _Tscalar | int) -> Self: ... - def __rfloordiv__(self, other: _Tscalar | int) -> Self: ... - def __mod__(self, other: Self | _Tscalar | int) -> Self: ... - def __rmod__(self, other: _Tscalar | int) -> Self: ... - def __divmod__( - self, other: Self | _Tscalar | int - ) -> tuple[Self, Self]: ... - def __rdivmod__(self, other: _Tscalar | int) -> tuple[Self, Self]: ... - def __pow__(self, other: _Tscalar | int) -> Self: ... - def __rpow__(self, other: _Tscalar | int) -> Self: ... - def iadd(self, other: _Tscalar | int) -> None: ... - def isub(self, other: _Tscalar | int) -> None: ... - def imul(self, other: _Tscalar | int) -> None: ... - def gcd(self, other: Self) -> Self: ... - def term_content(self) -> Self: ... - def factor(self) -> tuple[_Tscalar, Sequence[tuple[Self, int]]]: ... - def factor_squarefree(self) -> tuple[_Tscalar, Sequence[tuple[Self, int]]]: ... - def sqrt(self) -> Self: ... - def resultant(self, other: Self, var: _str | int) -> Self: ... - def discriminant(self, var: _str | int) -> Self: ... - def deflation_index(self) -> tuple[list[int], list[int]]: ... - def deflation(self) -> tuple[Self, list[int]]: ... - def deflation_monom(self) -> tuple[Self, list[int], Self]: ... - def inflate(self, N: list[int]) -> Self: ... - def deflate(self, N: list[int]) -> Self: ... - def subs(self, mapping: Mapping[_str | int, _Tscalar | int]) -> Self: ... - def compose(self, *args: Self, ctx: Any | None = None) -> Self: ... - def __call__(self, *args: _Tscalar) -> _Tscalar: ... - def derivative(self, var: _str | int) -> Self: ... - def unused_gens(self) -> tuple[_str, ...]: ... - def project_to_context( - self, other_ctx: Any, mapping: dict[_str | int, _str | int] | None = None - ) -> Self: ... - - -_Tmpoly_p = TypeVar("_Tmpoly_p", bound=mpoly_p, covariant=True) - - -class mpoly_context_p(elem_p, Protocol[_Tmpoly_p, _Tscalar_contra]): - def nvars(self) -> int: ... - def ordering(self) -> Ordering: ... - def gen(self, i: int, /) -> _Tmpoly_p: ... - def from_dict(self, d: Mapping[tuple[int, ...], _Tscalar_contra | int], /) -> _Tmpoly_p: ... - def constant(self, z: _Tscalar_contra | int, /) -> _Tmpoly_p: ... - def name(self, i: int, /) -> str: ... - def names(self) -> tuple[str, ...]: ... - def gens(self) -> tuple[_Tmpoly_p, ...]: ... - def variable_to_index(self, var: str, /) -> int: ... - def term( - self, coeff: _Tscalar_contra | None = None, exp_vec: Iterable[int] | None = None - ) -> _Tmpoly_p: ... - def drop_gens(self, gens: Iterable[str | int], /) -> Self: ... - def append_gens(self, gens: Iterable[str | int], /) -> Self: ... - def infer_generator_mapping( - self, ctx: Self, / - ) -> dict[int, int]: ... - @classmethod - def from_context( - cls, - ctx: flint_mpoly_context, # make a protocol for this? - names: str | Iterable[str | tuple[str, int]] | tuple[str, int] | None = None, - ordering: Ordering | str = Ordering.lex, - ) -> Self: ... - - -if TYPE_CHECKING: - - import flint as _f - - _x1: scalar_p = _f.fmpz(1) - _x2: scalar_p = _f.fmpq(1, 2) - _x3: scalar_p = _f.nmod(1, 2) - _x4: scalar_p = _f.fmpz_mod(1, _f.fmpz_mod_ctx(2)) - _x5: scalar_p = _f.fq_default(1, _f.fq_default_ctx(2)) - # XXX: Add arf, acf, arb, acb, ... - - _Tscalar0 = TypeVar("_Tscalar0", bound=scalar_p) - - def _scalar(x: _Tscalar0, y: _Tscalar0) -> _Tscalar0: - z = x + y + 1 - z = z / z + x**2 - z = 1 / z + 1**z - return z - - _y1: poly_p[_f.fmpz] = _f.fmpz_poly([1, 2]) - _y2: poly_p[_f.fmpq] = _f.fmpq_poly([1, 2]) - _y3: poly_p[_f.nmod] = _f.nmod_poly(1, 2) - _y4: poly_p[_f.fmpz_mod] = _f.fmpz_mod_poly(1, _f.fmpz_mod_poly_ctx(2)) - _y5: poly_p[_f.fq_default] = _f.fq_default_poly(1, _f.fq_default_poly_ctx(2)) - # XXX: Add arb_poly, acb_poly, ... - - def _poly(x: epoly_p[_Tscalar0], y: epoly_p[_Tscalar0]) -> epoly_p[_Tscalar0]: - z = x + y + 1 - z = z / z + x**2 - z = 1 / z + z.coeffs()[0] - return z - - _z1: epoly_p[_f.fmpz] = _f.fmpz_poly([1, 2]) - _z2: epoly_p[_f.fmpq] = _f.fmpq_poly([1, 2]) - _z3: epoly_p[_f.nmod] = _f.nmod_poly(1, 2) - _z4: epoly_p[_f.fmpz_mod] = _f.fmpz_mod_poly(1, _f.fmpz_mod_poly_ctx(2)) - _z5: epoly_p[_f.fq_default] = _f.fq_default_poly(1, _f.fq_default_poly_ctx(2)) - - def _epoly(x: epoly_p[_Tscalar0], y: epoly_p[_Tscalar0]) -> epoly_p[_Tscalar0]: - return x.gcd(y).factor()[1][0][0] - - _ctx1: mpoly_context_p[_f.fmpz_mpoly, _f.fmpz] = _f.fmpz_mpoly_ctx.get(['x', 'y']) - _ctx2: mpoly_context_p[_f.fmpq_mpoly, _f.fmpq] = _f.fmpq_mpoly_ctx.get(['x', 'y']) - _ctx3: mpoly_context_p[_f.nmod_mpoly, _f.nmod] = _f.nmod_mpoly_ctx.get(['x', 'y'], modulus=7) - _ctx4: mpoly_context_p[_f.fmpz_mod_mpoly, _f.fmpz_mod] = _f.fmpz_mod_mpoly_ctx.get(['x', 'y'], modulus=7) - - _p1: mpoly_p[_f.fmpz] = _ctx1.gens()[0] - _p2: mpoly_p[_f.fmpq] = _ctx2.gens()[0] - _p3: mpoly_p[_f.nmod] = _ctx3.gens()[0] - _p4: mpoly_p[_f.fmpz_mod] = _ctx4.gens()[0] - - _Tmpoly0 = TypeVar("_Tmpoly0", bound=mpoly_p) - - def _mpoly(x: mpoly_p[_Tscalar], y: mpoly_p[_Tscalar], ctx: mpoly_context_p[_Tmpoly0, _Tscalar]) -> mpoly_p[_Tscalar]: - z = x.gcd(y).factor()[1][0][0] + ctx.gens()[0] - t = z.compose(z, ctx=ctx) + z.context().gens()[0] - return t diff --git a/src/flint/utils/__init__.py b/src/flint/utils/__init__.py deleted file mode 100644 index e69de29b..00000000 diff --git a/src/flint/utils/conversion.pxd b/src/flint/utils/conversion.pxd deleted file mode 100644 index 2ae46001..00000000 --- a/src/flint/utils/conversion.pxd +++ /dev/null @@ -1,18 +0,0 @@ -cdef inline long prec_to_dps(n): - return max(1, int(round(int(n)/3.3219280948873626)-1)) - -cdef inline long dps_to_prec(n): - return max(1, int(round((int(n)+1)*3.3219280948873626))) - -cdef inline chars_from_str(s): - return s.encode('ascii') - -cdef inline str_from_chars(s): - return bytes(s).decode('ascii') - -cdef inline _str_trunc(s, trunc=0): - if trunc > 0 and len(s) > 3 * trunc: - left = right = trunc - omitted = len(s) - left - right - return s[:left] + ("{...%s digits...}" % omitted) + s[-right:] - return s diff --git a/src/flint/utils/flint_exceptions.py b/src/flint/utils/flint_exceptions.py deleted file mode 100644 index 00ce90eb..00000000 --- a/src/flint/utils/flint_exceptions.py +++ /dev/null @@ -1,34 +0,0 @@ -class FlintError(Exception): - """Generic parent class for all flint relation exceptions.""" - pass - - -class DomainError(FlintError): - """ - Exception intended to be called when a method is called on a - ring or field for which the domain is invalid. - """ - pass - - -class IncompatibleContextError(FlintError): - """ - Exception intended to be called when a method involves two or more - incompatible contexts. - """ - pass - - -class UnableError(FlintError): - """ - Exception intended to be called when the implementation is unable to - perform the requested operation. - """ - pass - - -class UnknownError(FlintError): - """ - Exception intended to be called when the value of a predicate is unknown. - """ - pass diff --git a/src/flint/utils/meson.build b/src/flint/utils/meson.build deleted file mode 100644 index 8ec2da5c..00000000 --- a/src/flint/utils/meson.build +++ /dev/null @@ -1,25 +0,0 @@ -thisdir = 'flint/utils' - -pyfiles = [ - '__init__.py', - 'flint_exceptions.py', -] - -exts = [] - -py.install_sources( - pyfiles, - pure: false, - subdir: thisdir, -) - -foreach ext : exts - py.extension_module( - ext, - ext + '.pyx', - dependencies: pyflint_deps, - install: true, - subdir: thisdir, - limited_api: limited_api_version, - ) -endforeach diff --git a/src/flint/utils/typecheck.pxd b/src/flint/utils/typecheck.pxd deleted file mode 100644 index 6e48be96..00000000 --- a/src/flint/utils/typecheck.pxd +++ /dev/null @@ -1,4 +0,0 @@ -from cpython.object cimport PyTypeObject, PyObject_TypeCheck - -cdef inline bint typecheck(object ob, object tp): - return PyObject_TypeCheck(ob, tp) diff --git a/wheels/gcc/COPYING.LIB b/wheels/gcc/COPYING.LIB deleted file mode 100644 index 2d2d780e..00000000 --- a/wheels/gcc/COPYING.LIB +++ /dev/null @@ -1,510 +0,0 @@ - - GNU LESSER GENERAL PUBLIC LICENSE - Version 2.1, February 1999 - - Copyright (C) 1991, 1999 Free Software Foundation, Inc. - 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - -[This is the first released version of the Lesser GPL. It also counts - as the successor of the GNU Library Public License, version 2, hence - the version number 2.1.] - - Preamble - - The licenses for most software are designed to take away your -freedom to share and change it. By contrast, the GNU General Public -Licenses are intended to guarantee your freedom to share and change -free software--to make sure the software is free for all its users. - - This license, the Lesser General Public License, applies to some -specially designated software packages--typically libraries--of the -Free Software Foundation and other authors who decide to use it. You -can use it too, but we suggest you first think carefully about whether -this license or the ordinary General Public License is the better -strategy to use in any particular case, based on the explanations -below. - - When we speak of free software, we are referring to freedom of use, -not price. Our General Public Licenses are designed to make sure that -you have the freedom to distribute copies of free software (and charge -for this service if you wish); that you receive source code or can get -it if you want it; that you can change the software and use pieces of -it in new free programs; and that you are informed that you can do -these things. - - To protect your rights, we need to make restrictions that forbid -distributors to deny you these rights or to ask you to surrender these -rights. These restrictions translate to certain responsibilities for -you if you distribute copies of the library or if you modify it. - - For example, if you distribute copies of the library, whether gratis -or for a fee, you must give the recipients all the rights that we gave -you. You must make sure that they, too, receive or can get the source -code. If you link other code with the library, you must provide -complete object files to the recipients, so that they can relink them -with the library after making changes to the library and recompiling -it. And you must show them these terms so they know their rights. - - We protect your rights with a two-step method: (1) we copyright the -library, and (2) we offer you this license, which gives you legal -permission to copy, distribute and/or modify the library. - - To protect each distributor, we want to make it very clear that -there is no warranty for the free library. Also, if the library is -modified by someone else and passed on, the recipients should know -that what they have is not the original version, so that the original -author's reputation will not be affected by problems that might be -introduced by others. - - Finally, software patents pose a constant threat to the existence of -any free program. We wish to make sure that a company cannot -effectively restrict the users of a free program by obtaining a -restrictive license from a patent holder. Therefore, we insist that -any patent license obtained for a version of the library must be -consistent with the full freedom of use specified in this license. - - Most GNU software, including some libraries, is covered by the -ordinary GNU General Public License. This license, the GNU Lesser -General Public License, applies to certain designated libraries, and -is quite different from the ordinary General Public License. We use -this license for certain libraries in order to permit linking those -libraries into non-free programs. - - When a program is linked with a library, whether statically or using -a shared library, the combination of the two is legally speaking a -combined work, a derivative of the original library. The ordinary -General Public License therefore permits such linking only if the -entire combination fits its criteria of freedom. The Lesser General -Public License permits more lax criteria for linking other code with -the library. - - We call this license the "Lesser" General Public License because it -does Less to protect the user's freedom than the ordinary General -Public License. It also provides other free software developers Less -of an advantage over competing non-free programs. These disadvantages -are the reason we use the ordinary General Public License for many -libraries. However, the Lesser license provides advantages in certain -special circumstances. - - For example, on rare occasions, there may be a special need to -encourage the widest possible use of a certain library, so that it -becomes a de-facto standard. To achieve this, non-free programs must -be allowed to use the library. A more frequent case is that a free -library does the same job as widely used non-free libraries. In this -case, there is little to gain by limiting the free library to free -software only, so we use the Lesser General Public License. - - In other cases, permission to use a particular library in non-free -programs enables a greater number of people to use a large body of -free software. For example, permission to use the GNU C Library in -non-free programs enables many more people to use the whole GNU -operating system, as well as its variant, the GNU/Linux operating -system. - - Although the Lesser General Public License is Less protective of the -users' freedom, it does ensure that the user of a program that is -linked with the Library has the freedom and the wherewithal to run -that program using a modified version of the Library. - - The precise terms and conditions for copying, distribution and -modification follow. Pay close attention to the difference between a -"work based on the library" and a "work that uses the library". The -former contains code derived from the library, whereas the latter must -be combined with the library in order to run. - - GNU LESSER GENERAL PUBLIC LICENSE - TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION - - 0. This License Agreement applies to any software library or other -program which contains a notice placed by the copyright holder or -other authorized party saying it may be distributed under the terms of -this Lesser General Public License (also called "this License"). -Each licensee is addressed as "you". - - A "library" means a collection of software functions and/or data -prepared so as to be conveniently linked with application programs -(which use some of those functions and data) to form executables. - - The "Library", below, refers to any such software library or work -which has been distributed under these terms. A "work based on the -Library" means either the Library or any derivative work under -copyright law: that is to say, a work containing the Library or a -portion of it, either verbatim or with modifications and/or translated -straightforwardly into another language. (Hereinafter, translation is -included without limitation in the term "modification".) - - "Source code" for a work means the preferred form of the work for -making modifications to it. For a library, complete source code means -all the source code for all modules it contains, plus any associated -interface definition files, plus the scripts used to control -compilation and installation of the library. - - Activities other than copying, distribution and modification are not -covered by this License; they are outside its scope. The act of -running a program using the Library is not restricted, and output from -such a program is covered only if its contents constitute a work based -on the Library (independent of the use of the Library in a tool for -writing it). Whether that is true depends on what the Library does -and what the program that uses the Library does. - - 1. You may copy and distribute verbatim copies of the Library's -complete source code as you receive it, in any medium, provided that -you conspicuously and appropriately publish on each copy an -appropriate copyright notice and disclaimer of warranty; keep intact -all the notices that refer to this License and to the absence of any -warranty; and distribute a copy of this License along with the -Library. - - You may charge a fee for the physical act of transferring a copy, -and you may at your option offer warranty protection in exchange for a -fee. - - 2. You may modify your copy or copies of the Library or any portion -of it, thus forming a work based on the Library, and copy and -distribute such modifications or work under the terms of Section 1 -above, provided that you also meet all of these conditions: - - a) The modified work must itself be a software library. - - b) You must cause the files modified to carry prominent notices - stating that you changed the files and the date of any change. - - c) You must cause the whole of the work to be licensed at no - charge to all third parties under the terms of this License. - - d) If a facility in the modified Library refers to a function or a - table of data to be supplied by an application program that uses - the facility, other than as an argument passed when the facility - is invoked, then you must make a good faith effort to ensure that, - in the event an application does not supply such function or - table, the facility still operates, and performs whatever part of - its purpose remains meaningful. - - (For example, a function in a library to compute square roots has - a purpose that is entirely well-defined independent of the - application. Therefore, Subsection 2d requires that any - application-supplied function or table used by this function must - be optional: if the application does not supply it, the square - root function must still compute square roots.) - -These requirements apply to the modified work as a whole. If -identifiable sections of that work are not derived from the Library, -and can be reasonably considered independent and separate works in -themselves, then this License, and its terms, do not apply to those -sections when you distribute them as separate works. But when you -distribute the same sections as part of a whole which is a work based -on the Library, the distribution of the whole must be on the terms of -this License, whose permissions for other licensees extend to the -entire whole, and thus to each and every part regardless of who wrote -it. - -Thus, it is not the intent of this section to claim rights or contest -your rights to work written entirely by you; rather, the intent is to -exercise the right to control the distribution of derivative or -collective works based on the Library. - -In addition, mere aggregation of another work not based on the Library -with the Library (or with a work based on the Library) on a volume of -a storage or distribution medium does not bring the other work under -the scope of this License. - - 3. You may opt to apply the terms of the ordinary GNU General Public -License instead of this License to a given copy of the Library. To do -this, you must alter all the notices that refer to this License, so -that they refer to the ordinary GNU General Public License, version 2, -instead of to this License. (If a newer version than version 2 of the -ordinary GNU General Public License has appeared, then you can specify -that version instead if you wish.) Do not make any other change in -these notices. - - Once this change is made in a given copy, it is irreversible for -that copy, so the ordinary GNU General Public License applies to all -subsequent copies and derivative works made from that copy. - - This option is useful when you wish to copy part of the code of -the Library into a program that is not a library. - - 4. You may copy and distribute the Library (or a portion or -derivative of it, under Section 2) in object code or executable form -under the terms of Sections 1 and 2 above provided that you accompany -it with the complete corresponding machine-readable source code, which -must be distributed under the terms of Sections 1 and 2 above on a -medium customarily used for software interchange. - - If distribution of object code is made by offering access to copy -from a designated place, then offering equivalent access to copy the -source code from the same place satisfies the requirement to -distribute the source code, even though third parties are not -compelled to copy the source along with the object code. - - 5. A program that contains no derivative of any portion of the -Library, but is designed to work with the Library by being compiled or -linked with it, is called a "work that uses the Library". Such a -work, in isolation, is not a derivative work of the Library, and -therefore falls outside the scope of this License. - - However, linking a "work that uses the Library" with the Library -creates an executable that is a derivative of the Library (because it -contains portions of the Library), rather than a "work that uses the -library". The executable is therefore covered by this License. -Section 6 states terms for distribution of such executables. - - When a "work that uses the Library" uses material from a header file -that is part of the Library, the object code for the work may be a -derivative work of the Library even though the source code is not. -Whether this is true is especially significant if the work can be -linked without the Library, or if the work is itself a library. The -threshold for this to be true is not precisely defined by law. - - If such an object file uses only numerical parameters, data -structure layouts and accessors, and small macros and small inline -functions (ten lines or less in length), then the use of the object -file is unrestricted, regardless of whether it is legally a derivative -work. (Executables containing this object code plus portions of the -Library will still fall under Section 6.) - - Otherwise, if the work is a derivative of the Library, you may -distribute the object code for the work under the terms of Section 6. -Any executables containing that work also fall under Section 6, -whether or not they are linked directly with the Library itself. - - 6. As an exception to the Sections above, you may also combine or -link a "work that uses the Library" with the Library to produce a -work containing portions of the Library, and distribute that work -under terms of your choice, provided that the terms permit -modification of the work for the customer's own use and reverse -engineering for debugging such modifications. - - You must give prominent notice with each copy of the work that the -Library is used in it and that the Library and its use are covered by -this License. You must supply a copy of this License. If the work -during execution displays copyright notices, you must include the -copyright notice for the Library among them, as well as a reference -directing the user to the copy of this License. Also, you must do one -of these things: - - a) Accompany the work with the complete corresponding - machine-readable source code for the Library including whatever - changes were used in the work (which must be distributed under - Sections 1 and 2 above); and, if the work is an executable linked - with the Library, with the complete machine-readable "work that - uses the Library", as object code and/or source code, so that the - user can modify the Library and then relink to produce a modified - executable containing the modified Library. (It is understood - that the user who changes the contents of definitions files in the - Library will not necessarily be able to recompile the application - to use the modified definitions.) - - b) Use a suitable shared library mechanism for linking with the - Library. A suitable mechanism is one that (1) uses at run time a - copy of the library already present on the user's computer system, - rather than copying library functions into the executable, and (2) - will operate properly with a modified version of the library, if - the user installs one, as long as the modified version is - interface-compatible with the version that the work was made with. - - c) Accompany the work with a written offer, valid for at least - three years, to give the same user the materials specified in - Subsection 6a, above, for a charge no more than the cost of - performing this distribution. - - d) If distribution of the work is made by offering access to copy - from a designated place, offer equivalent access to copy the above - specified materials from the same place. - - e) Verify that the user has already received a copy of these - materials or that you have already sent this user a copy. - - For an executable, the required form of the "work that uses the -Library" must include any data and utility programs needed for -reproducing the executable from it. However, as a special exception, -the materials to be distributed need not include anything that is -normally distributed (in either source or binary form) with the major -components (compiler, kernel, and so on) of the operating system on -which the executable runs, unless that component itself accompanies -the executable. - - It may happen that this requirement contradicts the license -restrictions of other proprietary libraries that do not normally -accompany the operating system. Such a contradiction means you cannot -use both them and the Library together in an executable that you -distribute. - - 7. You may place library facilities that are a work based on the -Library side-by-side in a single library together with other library -facilities not covered by this License, and distribute such a combined -library, provided that the separate distribution of the work based on -the Library and of the other library facilities is otherwise -permitted, and provided that you do these two things: - - a) Accompany the combined library with a copy of the same work - based on the Library, uncombined with any other library - facilities. This must be distributed under the terms of the - Sections above. - - b) Give prominent notice with the combined library of the fact - that part of it is a work based on the Library, and explaining - where to find the accompanying uncombined form of the same work. - - 8. You may not copy, modify, sublicense, link with, or distribute -the Library except as expressly provided under this License. Any -attempt otherwise to copy, modify, sublicense, link with, or -distribute the Library is void, and will automatically terminate your -rights under this License. However, parties who have received copies, -or rights, from you under this License will not have their licenses -terminated so long as such parties remain in full compliance. - - 9. You are not required to accept this License, since you have not -signed it. However, nothing else grants you permission to modify or -distribute the Library or its derivative works. These actions are -prohibited by law if you do not accept this License. Therefore, by -modifying or distributing the Library (or any work based on the -Library), you indicate your acceptance of this License to do so, and -all its terms and conditions for copying, distributing or modifying -the Library or works based on it. - - 10. Each time you redistribute the Library (or any work based on the -Library), the recipient automatically receives a license from the -original licensor to copy, distribute, link with or modify the Library -subject to these terms and conditions. You may not impose any further -restrictions on the recipients' exercise of the rights granted herein. -You are not responsible for enforcing compliance by third parties with -this License. - - 11. If, as a consequence of a court judgment or allegation of patent -infringement or for any other reason (not limited to patent issues), -conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot -distribute so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you -may not distribute the Library at all. For example, if a patent -license would not permit royalty-free redistribution of the Library by -all those who receive copies directly or indirectly through you, then -the only way you could satisfy both it and this License would be to -refrain entirely from distribution of the Library. - -If any portion of this section is held invalid or unenforceable under -any particular circumstance, the balance of the section is intended to -apply, and the section as a whole is intended to apply in other -circumstances. - -It is not the purpose of this section to induce you to infringe any -patents or other property right claims or to contest validity of any -such claims; this section has the sole purpose of protecting the -integrity of the free software distribution system which is -implemented by public license practices. Many people have made -generous contributions to the wide range of software distributed -through that system in reliance on consistent application of that -system; it is up to the author/donor to decide if he or she is willing -to distribute software through any other system and a licensee cannot -impose that choice. - -This section is intended to make thoroughly clear what is believed to -be a consequence of the rest of this License. - - 12. If the distribution and/or use of the Library is restricted in -certain countries either by patents or by copyrighted interfaces, the -original copyright holder who places the Library under this License -may add an explicit geographical distribution limitation excluding those -countries, so that distribution is permitted only in or among -countries not thus excluded. In such case, this License incorporates -the limitation as if written in the body of this License. - - 13. The Free Software Foundation may publish revised and/or new -versions of the Lesser General Public License from time to time. -Such new versions will be similar in spirit to the present version, -but may differ in detail to address new problems or concerns. - -Each version is given a distinguishing version number. If the Library -specifies a version number of this License which applies to it and -"any later version", you have the option of following the terms and -conditions either of that version or of any later version published by -the Free Software Foundation. If the Library does not specify a -license version number, you may choose any version ever published by -the Free Software Foundation. - - 14. If you wish to incorporate parts of the Library into other free -programs whose distribution conditions are incompatible with these, -write to the author to ask for permission. For software which is -copyrighted by the Free Software Foundation, write to the Free -Software Foundation; we sometimes make exceptions for this. Our -decision will be guided by the two goals of preserving the free status -of all derivatives of our free software and of promoting the sharing -and reuse of software generally. - - NO WARRANTY - - 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO -WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. -EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR -OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY -KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE -LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME -THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN -WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY -AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU -FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR -CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE -LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING -RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A -FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF -SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH -DAMAGES. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Libraries - - If you develop a new library, and you want it to be of the greatest -possible use to the public, we recommend making it free software that -everyone can redistribute and change. You can do so by permitting -redistribution under these terms (or, alternatively, under the terms -of the ordinary General Public License). - - To apply these terms, attach the following notices to the library. -It is safest to attach them to the start of each source file to most -effectively convey the exclusion of warranty; and each file should -have at least the "copyright" line and a pointer to where the full -notice is found. - - - - Copyright (C) - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA - -Also add information on how to contact you by electronic and paper mail. - -You should also get your employer (if you work as a programmer) or -your school, if any, to sign a "copyright disclaimer" for the library, -if necessary. Here is a sample; alter the names: - - Yoyodyne, Inc., hereby disclaims all copyright interest in the - library `Frob' (a library for tweaking knobs) written by James - Random Hacker. - - , 1 April 1990 - Ty Coon, President of Vice - -That's all there is to it! - - diff --git a/wheels/gcc/COPYING.RUNTIME b/wheels/gcc/COPYING.RUNTIME deleted file mode 100644 index e1b3c69c..00000000 --- a/wheels/gcc/COPYING.RUNTIME +++ /dev/null @@ -1,73 +0,0 @@ -GCC RUNTIME LIBRARY EXCEPTION - -Version 3.1, 31 March 2009 - -Copyright (C) 2009 Free Software Foundation, Inc. - -Everyone is permitted to copy and distribute verbatim copies of this -license document, but changing it is not allowed. - -This GCC Runtime Library Exception ("Exception") is an additional -permission under section 7 of the GNU General Public License, version -3 ("GPLv3"). It applies to a given file (the "Runtime Library") that -bears a notice placed by the copyright holder of the file stating that -the file is governed by GPLv3 along with this Exception. - -When you use GCC to compile a program, GCC may combine portions of -certain GCC header files and runtime libraries with the compiled -program. The purpose of this Exception is to allow compilation of -non-GPL (including proprietary) programs to use, in this way, the -header files and runtime libraries covered by this Exception. - -0. Definitions. - -A file is an "Independent Module" if it either requires the Runtime -Library for execution after a Compilation Process, or makes use of an -interface provided by the Runtime Library, but is not otherwise based -on the Runtime Library. - -"GCC" means a version of the GNU Compiler Collection, with or without -modifications, governed by version 3 (or a specified later version) of -the GNU General Public License (GPL) with the option of using any -subsequent versions published by the FSF. - -"GPL-compatible Software" is software whose conditions of propagation, -modification and use would permit combination with GCC in accord with -the license of GCC. - -"Target Code" refers to output from any compiler for a real or virtual -target processor architecture, in executable form or suitable for -input to an assembler, loader, linker and/or execution -phase. Notwithstanding that, Target Code does not include data in any -format that is used as a compiler intermediate representation, or used -for producing a compiler intermediate representation. - -The "Compilation Process" transforms code entirely represented in -non-intermediate languages designed for human-written code, and/or in -Java Virtual Machine byte code, into Target Code. Thus, for example, -use of source code generators and preprocessors need not be considered -part of the Compilation Process, since the Compilation Process can be -understood as starting with the output of the generators or -preprocessors. - -A Compilation Process is "Eligible" if it is done using GCC, alone or -with other GPL-compatible software, or if it is done without using any -work based on GCC. For example, using non-GPL-compatible Software to -optimize any GCC intermediate representations would not qualify as an -Eligible Compilation Process. - -1. Grant of Additional Permission. - -You have permission to propagate a work of Target Code formed by -combining the Runtime Library with Independent Modules, even if such -propagation would otherwise violate the terms of GPLv3, provided that -all Target Code was generated by Eligible Compilation Processes. You -may then convey such a combination under terms of your choice, -consistent with the licensing of the Independent Modules. - -2. No Weakening of GCC Copyleft. - -The availability of this Exception does not imply any general -presumption that third-party software is unaffected by the copyleft -requirements of the license of GCC. - diff --git a/wheels/gcc/COPYING3 b/wheels/gcc/COPYING3 deleted file mode 100644 index 94a9ed02..00000000 --- a/wheels/gcc/COPYING3 +++ /dev/null @@ -1,674 +0,0 @@ - GNU GENERAL PUBLIC LICENSE - Version 3, 29 June 2007 - - Copyright (C) 2007 Free Software Foundation, Inc. - Everyone is permitted to copy and distribute verbatim copies - of this license document, but changing it is not allowed. - - Preamble - - The GNU General Public License is a free, copyleft license for -software and other kinds of works. - - The licenses for most software and other practical works are designed -to take away your freedom to share and change the works. By contrast, -the GNU General Public License is intended to guarantee your freedom to -share and change all versions of a program--to make sure it remains free -software for all its users. We, the Free Software Foundation, use the -GNU General Public License for most of our software; it applies also to -any other work released this way by its authors. You can apply it to -your programs, too. - - When we speak of free software, we are referring to freedom, not -price. Our General Public Licenses are designed to make sure that you -have the freedom to distribute copies of free software (and charge for -them if you wish), that you receive source code or can get it if you -want it, that you can change the software or use pieces of it in new -free programs, and that you know you can do these things. - - To protect your rights, we need to prevent others from denying you -these rights or asking you to surrender the rights. Therefore, you have -certain responsibilities if you distribute copies of the software, or if -you modify it: responsibilities to respect the freedom of others. - - For example, if you distribute copies of such a program, whether -gratis or for a fee, you must pass on to the recipients the same -freedoms that you received. You must make sure that they, too, receive -or can get the source code. And you must show them these terms so they -know their rights. - - Developers that use the GNU GPL protect your rights with two steps: -(1) assert copyright on the software, and (2) offer you this License -giving you legal permission to copy, distribute and/or modify it. - - For the developers' and authors' protection, the GPL clearly explains -that there is no warranty for this free software. For both users' and -authors' sake, the GPL requires that modified versions be marked as -changed, so that their problems will not be attributed erroneously to -authors of previous versions. - - Some devices are designed to deny users access to install or run -modified versions of the software inside them, although the manufacturer -can do so. This is fundamentally incompatible with the aim of -protecting users' freedom to change the software. The systematic -pattern of such abuse occurs in the area of products for individuals to -use, which is precisely where it is most unacceptable. Therefore, we -have designed this version of the GPL to prohibit the practice for those -products. If such problems arise substantially in other domains, we -stand ready to extend this provision to those domains in future versions -of the GPL, as needed to protect the freedom of users. - - Finally, every program is threatened constantly by software patents. -States should not allow patents to restrict development and use of -software on general-purpose computers, but in those that do, we wish to -avoid the special danger that patents applied to a free program could -make it effectively proprietary. To prevent this, the GPL assures that -patents cannot be used to render the program non-free. - - The precise terms and conditions for copying, distribution and -modification follow. - - TERMS AND CONDITIONS - - 0. Definitions. - - "This License" refers to version 3 of the GNU General Public License. - - "Copyright" also means copyright-like laws that apply to other kinds of -works, such as semiconductor masks. - - "The Program" refers to any copyrightable work licensed under this -License. Each licensee is addressed as "you". "Licensees" and -"recipients" may be individuals or organizations. - - To "modify" a work means to copy from or adapt all or part of the work -in a fashion requiring copyright permission, other than the making of an -exact copy. The resulting work is called a "modified version" of the -earlier work or a work "based on" the earlier work. - - A "covered work" means either the unmodified Program or a work based -on the Program. - - To "propagate" a work means to do anything with it that, without -permission, would make you directly or secondarily liable for -infringement under applicable copyright law, except executing it on a -computer or modifying a private copy. Propagation includes copying, -distribution (with or without modification), making available to the -public, and in some countries other activities as well. - - To "convey" a work means any kind of propagation that enables other -parties to make or receive copies. Mere interaction with a user through -a computer network, with no transfer of a copy, is not conveying. - - An interactive user interface displays "Appropriate Legal Notices" -to the extent that it includes a convenient and prominently visible -feature that (1) displays an appropriate copyright notice, and (2) -tells the user that there is no warranty for the work (except to the -extent that warranties are provided), that licensees may convey the -work under this License, and how to view a copy of this License. If -the interface presents a list of user commands or options, such as a -menu, a prominent item in the list meets this criterion. - - 1. Source Code. - - The "source code" for a work means the preferred form of the work -for making modifications to it. "Object code" means any non-source -form of a work. - - A "Standard Interface" means an interface that either is an official -standard defined by a recognized standards body, or, in the case of -interfaces specified for a particular programming language, one that -is widely used among developers working in that language. - - The "System Libraries" of an executable work include anything, other -than the work as a whole, that (a) is included in the normal form of -packaging a Major Component, but which is not part of that Major -Component, and (b) serves only to enable use of the work with that -Major Component, or to implement a Standard Interface for which an -implementation is available to the public in source code form. A -"Major Component", in this context, means a major essential component -(kernel, window system, and so on) of the specific operating system -(if any) on which the executable work runs, or a compiler used to -produce the work, or an object code interpreter used to run it. - - The "Corresponding Source" for a work in object code form means all -the source code needed to generate, install, and (for an executable -work) run the object code and to modify the work, including scripts to -control those activities. However, it does not include the work's -System Libraries, or general-purpose tools or generally available free -programs which are used unmodified in performing those activities but -which are not part of the work. For example, Corresponding Source -includes interface definition files associated with source files for -the work, and the source code for shared libraries and dynamically -linked subprograms that the work is specifically designed to require, -such as by intimate data communication or control flow between those -subprograms and other parts of the work. - - The Corresponding Source need not include anything that users -can regenerate automatically from other parts of the Corresponding -Source. - - The Corresponding Source for a work in source code form is that -same work. - - 2. Basic Permissions. - - All rights granted under this License are granted for the term of -copyright on the Program, and are irrevocable provided the stated -conditions are met. This License explicitly affirms your unlimited -permission to run the unmodified Program. The output from running a -covered work is covered by this License only if the output, given its -content, constitutes a covered work. This License acknowledges your -rights of fair use or other equivalent, as provided by copyright law. - - You may make, run and propagate covered works that you do not -convey, without conditions so long as your license otherwise remains -in force. You may convey covered works to others for the sole purpose -of having them make modifications exclusively for you, or provide you -with facilities for running those works, provided that you comply with -the terms of this License in conveying all material for which you do -not control copyright. Those thus making or running the covered works -for you must do so exclusively on your behalf, under your direction -and control, on terms that prohibit them from making any copies of -your copyrighted material outside their relationship with you. - - Conveying under any other circumstances is permitted solely under -the conditions stated below. Sublicensing is not allowed; section 10 -makes it unnecessary. - - 3. Protecting Users' Legal Rights From Anti-Circumvention Law. - - No covered work shall be deemed part of an effective technological -measure under any applicable law fulfilling obligations under article -11 of the WIPO copyright treaty adopted on 20 December 1996, or -similar laws prohibiting or restricting circumvention of such -measures. - - When you convey a covered work, you waive any legal power to forbid -circumvention of technological measures to the extent such circumvention -is effected by exercising rights under this License with respect to -the covered work, and you disclaim any intention to limit operation or -modification of the work as a means of enforcing, against the work's -users, your or third parties' legal rights to forbid circumvention of -technological measures. - - 4. Conveying Verbatim Copies. - - You may convey verbatim copies of the Program's source code as you -receive it, in any medium, provided that you conspicuously and -appropriately publish on each copy an appropriate copyright notice; -keep intact all notices stating that this License and any -non-permissive terms added in accord with section 7 apply to the code; -keep intact all notices of the absence of any warranty; and give all -recipients a copy of this License along with the Program. - - You may charge any price or no price for each copy that you convey, -and you may offer support or warranty protection for a fee. - - 5. Conveying Modified Source Versions. - - You may convey a work based on the Program, or the modifications to -produce it from the Program, in the form of source code under the -terms of section 4, provided that you also meet all of these conditions: - - a) The work must carry prominent notices stating that you modified - it, and giving a relevant date. - - b) The work must carry prominent notices stating that it is - released under this License and any conditions added under section - 7. This requirement modifies the requirement in section 4 to - "keep intact all notices". - - c) You must license the entire work, as a whole, under this - License to anyone who comes into possession of a copy. This - License will therefore apply, along with any applicable section 7 - additional terms, to the whole of the work, and all its parts, - regardless of how they are packaged. This License gives no - permission to license the work in any other way, but it does not - invalidate such permission if you have separately received it. - - d) If the work has interactive user interfaces, each must display - Appropriate Legal Notices; however, if the Program has interactive - interfaces that do not display Appropriate Legal Notices, your - work need not make them do so. - - A compilation of a covered work with other separate and independent -works, which are not by their nature extensions of the covered work, -and which are not combined with it such as to form a larger program, -in or on a volume of a storage or distribution medium, is called an -"aggregate" if the compilation and its resulting copyright are not -used to limit the access or legal rights of the compilation's users -beyond what the individual works permit. Inclusion of a covered work -in an aggregate does not cause this License to apply to the other -parts of the aggregate. - - 6. Conveying Non-Source Forms. - - You may convey a covered work in object code form under the terms -of sections 4 and 5, provided that you also convey the -machine-readable Corresponding Source under the terms of this License, -in one of these ways: - - a) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by the - Corresponding Source fixed on a durable physical medium - customarily used for software interchange. - - b) Convey the object code in, or embodied in, a physical product - (including a physical distribution medium), accompanied by a - written offer, valid for at least three years and valid for as - long as you offer spare parts or customer support for that product - model, to give anyone who possesses the object code either (1) a - copy of the Corresponding Source for all the software in the - product that is covered by this License, on a durable physical - medium customarily used for software interchange, for a price no - more than your reasonable cost of physically performing this - conveying of source, or (2) access to copy the - Corresponding Source from a network server at no charge. - - c) Convey individual copies of the object code with a copy of the - written offer to provide the Corresponding Source. This - alternative is allowed only occasionally and noncommercially, and - only if you received the object code with such an offer, in accord - with subsection 6b. - - d) Convey the object code by offering access from a designated - place (gratis or for a charge), and offer equivalent access to the - Corresponding Source in the same way through the same place at no - further charge. You need not require recipients to copy the - Corresponding Source along with the object code. If the place to - copy the object code is a network server, the Corresponding Source - may be on a different server (operated by you or a third party) - that supports equivalent copying facilities, provided you maintain - clear directions next to the object code saying where to find the - Corresponding Source. Regardless of what server hosts the - Corresponding Source, you remain obligated to ensure that it is - available for as long as needed to satisfy these requirements. - - e) Convey the object code using peer-to-peer transmission, provided - you inform other peers where the object code and Corresponding - Source of the work are being offered to the general public at no - charge under subsection 6d. - - A separable portion of the object code, whose source code is excluded -from the Corresponding Source as a System Library, need not be -included in conveying the object code work. - - A "User Product" is either (1) a "consumer product", which means any -tangible personal property which is normally used for personal, family, -or household purposes, or (2) anything designed or sold for incorporation -into a dwelling. In determining whether a product is a consumer product, -doubtful cases shall be resolved in favor of coverage. For a particular -product received by a particular user, "normally used" refers to a -typical or common use of that class of product, regardless of the status -of the particular user or of the way in which the particular user -actually uses, or expects or is expected to use, the product. A product -is a consumer product regardless of whether the product has substantial -commercial, industrial or non-consumer uses, unless such uses represent -the only significant mode of use of the product. - - "Installation Information" for a User Product means any methods, -procedures, authorization keys, or other information required to install -and execute modified versions of a covered work in that User Product from -a modified version of its Corresponding Source. The information must -suffice to ensure that the continued functioning of the modified object -code is in no case prevented or interfered with solely because -modification has been made. - - If you convey an object code work under this section in, or with, or -specifically for use in, a User Product, and the conveying occurs as -part of a transaction in which the right of possession and use of the -User Product is transferred to the recipient in perpetuity or for a -fixed term (regardless of how the transaction is characterized), the -Corresponding Source conveyed under this section must be accompanied -by the Installation Information. But this requirement does not apply -if neither you nor any third party retains the ability to install -modified object code on the User Product (for example, the work has -been installed in ROM). - - The requirement to provide Installation Information does not include a -requirement to continue to provide support service, warranty, or updates -for a work that has been modified or installed by the recipient, or for -the User Product in which it has been modified or installed. Access to a -network may be denied when the modification itself materially and -adversely affects the operation of the network or violates the rules and -protocols for communication across the network. - - Corresponding Source conveyed, and Installation Information provided, -in accord with this section must be in a format that is publicly -documented (and with an implementation available to the public in -source code form), and must require no special password or key for -unpacking, reading or copying. - - 7. Additional Terms. - - "Additional permissions" are terms that supplement the terms of this -License by making exceptions from one or more of its conditions. -Additional permissions that are applicable to the entire Program shall -be treated as though they were included in this License, to the extent -that they are valid under applicable law. If additional permissions -apply only to part of the Program, that part may be used separately -under those permissions, but the entire Program remains governed by -this License without regard to the additional permissions. - - When you convey a copy of a covered work, you may at your option -remove any additional permissions from that copy, or from any part of -it. (Additional permissions may be written to require their own -removal in certain cases when you modify the work.) You may place -additional permissions on material, added by you to a covered work, -for which you have or can give appropriate copyright permission. - - Notwithstanding any other provision of this License, for material you -add to a covered work, you may (if authorized by the copyright holders of -that material) supplement the terms of this License with terms: - - a) Disclaiming warranty or limiting liability differently from the - terms of sections 15 and 16 of this License; or - - b) Requiring preservation of specified reasonable legal notices or - author attributions in that material or in the Appropriate Legal - Notices displayed by works containing it; or - - c) Prohibiting misrepresentation of the origin of that material, or - requiring that modified versions of such material be marked in - reasonable ways as different from the original version; or - - d) Limiting the use for publicity purposes of names of licensors or - authors of the material; or - - e) Declining to grant rights under trademark law for use of some - trade names, trademarks, or service marks; or - - f) Requiring indemnification of licensors and authors of that - material by anyone who conveys the material (or modified versions of - it) with contractual assumptions of liability to the recipient, for - any liability that these contractual assumptions directly impose on - those licensors and authors. - - All other non-permissive additional terms are considered "further -restrictions" within the meaning of section 10. If the Program as you -received it, or any part of it, contains a notice stating that it is -governed by this License along with a term that is a further -restriction, you may remove that term. If a license document contains -a further restriction but permits relicensing or conveying under this -License, you may add to a covered work material governed by the terms -of that license document, provided that the further restriction does -not survive such relicensing or conveying. - - If you add terms to a covered work in accord with this section, you -must place, in the relevant source files, a statement of the -additional terms that apply to those files, or a notice indicating -where to find the applicable terms. - - Additional terms, permissive or non-permissive, may be stated in the -form of a separately written license, or stated as exceptions; -the above requirements apply either way. - - 8. Termination. - - You may not propagate or modify a covered work except as expressly -provided under this License. Any attempt otherwise to propagate or -modify it is void, and will automatically terminate your rights under -this License (including any patent licenses granted under the third -paragraph of section 11). - - However, if you cease all violation of this License, then your -license from a particular copyright holder is reinstated (a) -provisionally, unless and until the copyright holder explicitly and -finally terminates your license, and (b) permanently, if the copyright -holder fails to notify you of the violation by some reasonable means -prior to 60 days after the cessation. - - Moreover, your license from a particular copyright holder is -reinstated permanently if the copyright holder notifies you of the -violation by some reasonable means, this is the first time you have -received notice of violation of this License (for any work) from that -copyright holder, and you cure the violation prior to 30 days after -your receipt of the notice. - - Termination of your rights under this section does not terminate the -licenses of parties who have received copies or rights from you under -this License. If your rights have been terminated and not permanently -reinstated, you do not qualify to receive new licenses for the same -material under section 10. - - 9. Acceptance Not Required for Having Copies. - - You are not required to accept this License in order to receive or -run a copy of the Program. Ancillary propagation of a covered work -occurring solely as a consequence of using peer-to-peer transmission -to receive a copy likewise does not require acceptance. However, -nothing other than this License grants you permission to propagate or -modify any covered work. These actions infringe copyright if you do -not accept this License. Therefore, by modifying or propagating a -covered work, you indicate your acceptance of this License to do so. - - 10. Automatic Licensing of Downstream Recipients. - - Each time you convey a covered work, the recipient automatically -receives a license from the original licensors, to run, modify and -propagate that work, subject to this License. You are not responsible -for enforcing compliance by third parties with this License. - - An "entity transaction" is a transaction transferring control of an -organization, or substantially all assets of one, or subdividing an -organization, or merging organizations. If propagation of a covered -work results from an entity transaction, each party to that -transaction who receives a copy of the work also receives whatever -licenses to the work the party's predecessor in interest had or could -give under the previous paragraph, plus a right to possession of the -Corresponding Source of the work from the predecessor in interest, if -the predecessor has it or can get it with reasonable efforts. - - You may not impose any further restrictions on the exercise of the -rights granted or affirmed under this License. For example, you may -not impose a license fee, royalty, or other charge for exercise of -rights granted under this License, and you may not initiate litigation -(including a cross-claim or counterclaim in a lawsuit) alleging that -any patent claim is infringed by making, using, selling, offering for -sale, or importing the Program or any portion of it. - - 11. Patents. - - A "contributor" is a copyright holder who authorizes use under this -License of the Program or a work on which the Program is based. The -work thus licensed is called the contributor's "contributor version". - - A contributor's "essential patent claims" are all patent claims -owned or controlled by the contributor, whether already acquired or -hereafter acquired, that would be infringed by some manner, permitted -by this License, of making, using, or selling its contributor version, -but do not include claims that would be infringed only as a -consequence of further modification of the contributor version. For -purposes of this definition, "control" includes the right to grant -patent sublicenses in a manner consistent with the requirements of -this License. - - Each contributor grants you a non-exclusive, worldwide, royalty-free -patent license under the contributor's essential patent claims, to -make, use, sell, offer for sale, import and otherwise run, modify and -propagate the contents of its contributor version. - - In the following three paragraphs, a "patent license" is any express -agreement or commitment, however denominated, not to enforce a patent -(such as an express permission to practice a patent or covenant not to -sue for patent infringement). To "grant" such a patent license to a -party means to make such an agreement or commitment not to enforce a -patent against the party. - - If you convey a covered work, knowingly relying on a patent license, -and the Corresponding Source of the work is not available for anyone -to copy, free of charge and under the terms of this License, through a -publicly available network server or other readily accessible means, -then you must either (1) cause the Corresponding Source to be so -available, or (2) arrange to deprive yourself of the benefit of the -patent license for this particular work, or (3) arrange, in a manner -consistent with the requirements of this License, to extend the patent -license to downstream recipients. "Knowingly relying" means you have -actual knowledge that, but for the patent license, your conveying the -covered work in a country, or your recipient's use of the covered work -in a country, would infringe one or more identifiable patents in that -country that you have reason to believe are valid. - - If, pursuant to or in connection with a single transaction or -arrangement, you convey, or propagate by procuring conveyance of, a -covered work, and grant a patent license to some of the parties -receiving the covered work authorizing them to use, propagate, modify -or convey a specific copy of the covered work, then the patent license -you grant is automatically extended to all recipients of the covered -work and works based on it. - - A patent license is "discriminatory" if it does not include within -the scope of its coverage, prohibits the exercise of, or is -conditioned on the non-exercise of one or more of the rights that are -specifically granted under this License. You may not convey a covered -work if you are a party to an arrangement with a third party that is -in the business of distributing software, under which you make payment -to the third party based on the extent of your activity of conveying -the work, and under which the third party grants, to any of the -parties who would receive the covered work from you, a discriminatory -patent license (a) in connection with copies of the covered work -conveyed by you (or copies made from those copies), or (b) primarily -for and in connection with specific products or compilations that -contain the covered work, unless you entered into that arrangement, -or that patent license was granted, prior to 28 March 2007. - - Nothing in this License shall be construed as excluding or limiting -any implied license or other defenses to infringement that may -otherwise be available to you under applicable patent law. - - 12. No Surrender of Others' Freedom. - - If conditions are imposed on you (whether by court order, agreement or -otherwise) that contradict the conditions of this License, they do not -excuse you from the conditions of this License. If you cannot convey a -covered work so as to satisfy simultaneously your obligations under this -License and any other pertinent obligations, then as a consequence you may -not convey it at all. For example, if you agree to terms that obligate you -to collect a royalty for further conveying from those to whom you convey -the Program, the only way you could satisfy both those terms and this -License would be to refrain entirely from conveying the Program. - - 13. Use with the GNU Affero General Public License. - - Notwithstanding any other provision of this License, you have -permission to link or combine any covered work with a work licensed -under version 3 of the GNU Affero General Public License into a single -combined work, and to convey the resulting work. The terms of this -License will continue to apply to the part which is the covered work, -but the special requirements of the GNU Affero General Public License, -section 13, concerning interaction through a network will apply to the -combination as such. - - 14. Revised Versions of this License. - - The Free Software Foundation may publish revised and/or new versions of -the GNU General Public License from time to time. Such new versions will -be similar in spirit to the present version, but may differ in detail to -address new problems or concerns. - - Each version is given a distinguishing version number. If the -Program specifies that a certain numbered version of the GNU General -Public License "or any later version" applies to it, you have the -option of following the terms and conditions either of that numbered -version or of any later version published by the Free Software -Foundation. If the Program does not specify a version number of the -GNU General Public License, you may choose any version ever published -by the Free Software Foundation. - - If the Program specifies that a proxy can decide which future -versions of the GNU General Public License can be used, that proxy's -public statement of acceptance of a version permanently authorizes you -to choose that version for the Program. - - Later license versions may give you additional or different -permissions. However, no additional obligations are imposed on any -author or copyright holder as a result of your choosing to follow a -later version. - - 15. Disclaimer of Warranty. - - THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY -APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT -HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY -OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, -THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR -PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM -IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF -ALL NECESSARY SERVICING, REPAIR OR CORRECTION. - - 16. Limitation of Liability. - - IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING -WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS -THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY -GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE -USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF -DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD -PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), -EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF -SUCH DAMAGES. - - 17. Interpretation of Sections 15 and 16. - - If the disclaimer of warranty and limitation of liability provided -above cannot be given local legal effect according to their terms, -reviewing courts shall apply local law that most closely approximates -an absolute waiver of all civil liability in connection with the -Program, unless a warranty or assumption of liability accompanies a -copy of the Program in return for a fee. - - END OF TERMS AND CONDITIONS - - How to Apply These Terms to Your New Programs - - If you develop a new program, and you want it to be of the greatest -possible use to the public, the best way to achieve this is to make it -free software which everyone can redistribute and change under these terms. - - To do so, attach the following notices to the program. It is safest -to attach them to the start of each source file to most effectively -state the exclusion of warranty; and each file should have at least -the "copyright" line and a pointer to where the full notice is found. - - - Copyright (C) - - This program is free software: you can redistribute it and/or modify - it under the terms of the GNU General Public License as published by - the Free Software Foundation, either version 3 of the License, or - (at your option) any later version. - - This program is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with this program. If not, see . - -Also add information on how to contact you by electronic and paper mail. - - If the program does terminal interaction, make it output a short -notice like this when it starts in an interactive mode: - - Copyright (C) - This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. - This is free software, and you are welcome to redistribute it - under certain conditions; type `show c' for details. - -The hypothetical commands `show w' and `show c' should show the appropriate -parts of the General Public License. Of course, your program's commands -might be different; for a GUI interface, you would use an "about box". - - You should also get your employer (if you work as a programmer) or school, -if any, to sign a "copyright disclaimer" for the program, if necessary. -For more information on this, and how to apply and follow the GNU GPL, see -. - - The GNU General Public License does not permit incorporating your program -into proprietary programs. If your program is a subroutine library, you -may consider it more useful to permit linking proprietary applications with -the library. If this is what you want to do, use the GNU Lesser General -Public License instead of this License. But first, please read -. diff --git a/wheels/winpthreads/COPYING b/wheels/winpthreads/COPYING deleted file mode 100644 index 35077012..00000000 --- a/wheels/winpthreads/COPYING +++ /dev/null @@ -1,57 +0,0 @@ -Copyright (c) 2011 mingw-w64 project - -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the "Software"), -to deal in the Software without restriction, including without limitation -the rights to use, copy, modify, merge, publish, distribute, sublicense, -and/or sell copies of the Software, and to permit persons to whom the -Software is furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in -all copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -DEALINGS IN THE SOFTWARE. - - -/* - * Parts of this library are derived by: - * - * Posix Threads library for Microsoft Windows - * - * Use at own risk, there is no implied warranty to this code. - * It uses undocumented features of Microsoft Windows that can change - * at any time in the future. - * - * (C) 2010 Lockless Inc. - * All rights reserved. - * - * Redistribution and use in source and binary forms, with or without modification, - * are permitted provided that the following conditions are met: - * - * - * * Redistributions of source code must retain the above copyright notice, - * this list of conditions and the following disclaimer. - * * Redistributions in binary form must reproduce the above copyright notice, - * this list of conditions and the following disclaimer in the documentation - * and/or other materials provided with the distribution. - * * Neither the name of Lockless Inc. nor the names of its contributors may be - * used to endorse or promote products derived from this software without - * specific prior written permission. - * - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AN - * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - * IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, - * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF - * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE - * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED - * OF THE POSSIBILITY OF SUCH DAMAGE. - */