diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..9414382 --- /dev/null +++ b/.dockerignore @@ -0,0 +1 @@ +Dockerfile diff --git a/.flake8 b/.flake8 new file mode 100644 index 0000000..0d31d68 --- /dev/null +++ b/.flake8 @@ -0,0 +1,9 @@ +[flake8] +max-line-length = 100 +inline-quotes = " +extend-ignore = + E203, +# E203 whitespace before ':' (to be compatible with black) +per-file-ignores = +# The api package re-exports its submodules for `from suitesparse_graphblas import api` + suitesparse_graphblas/api/__init__.py:F401, diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..5fa64ac --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,15 @@ +version: 2 +updates: + - package-ecosystem: 'github-actions' + directory: '/' + schedule: + interval: 'weekly' + # Wait a week after a release before proposing it, so a compromised or + # broken release has time to be noticed and yanked. + cooldown: + default-days: 7 + # One PR per week for all action bumps instead of one PR per action. + groups: + github-actions: + patterns: + - '*' diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml new file mode 100644 index 0000000..a6f536b --- /dev/null +++ b/.github/workflows/docs.yml @@ -0,0 +1,53 @@ +name: docs + +# Disabled: we don't have docs to deploy yet, so this only runs when +# triggered manually. Restore `push: branches: [main]` to re-enable. +on: + workflow_dispatch: + +permissions: + contents: read + +concurrency: + group: pages + cancel-in-progress: false + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + persist-credentials: false + + - name: Build package in Docker + run: | + docker build --target psg \ + --build-arg SUITESPARSE="v$(cat GB_VERSION.txt)" \ + --build-arg VERSION=99.0.0.0 \ + --build-arg COMPACT=1 \ + -t psg-docs . + + - name: Generate docs with pdoc + run: | + docker run --rm -v "$GITHUB_WORKSPACE/site:/out" psg-docs \ + bash -c "pip install --break-system-packages -q pdoc && \ + pdoc --output-directory /out --no-show-source --docformat numpy \ + suitesparse_graphblas.api" + + - uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 + with: + path: site/ + + deploy: + needs: build + runs-on: ubuntu-latest + permissions: + pages: write # to deploy to GitHub Pages + id-token: write # to prove the deployment comes from this workflow + environment: + name: github-pages + url: ${{ steps.deployment.outputs.page_url }} + steps: + - uses: actions/deploy-pages@368f82528645a54fb793d4d04e342629a3f51346 # v5.0.1 + id: deployment diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..b05ed8a --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,29 @@ +name: Lint via pre-commit + +on: + pull_request: + push: + branches-ignore: + - main + +permissions: + contents: read + +# Cancel superseded runs of a PR; never cancel branch pushes. +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +jobs: + pre-commit: + name: pre-commit-hooks + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + fetch-depth: 0 + persist-credentials: false + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + with: + python-version: "3.11" + - uses: pre-commit/action@2c7b3805fd2a0fd8c1884dcaebf91fc102a13ecd # v3.0.1 diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..8f16332 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,124 @@ +name: Test + +on: + push: + branches: [ main ] + pull_request: + +permissions: + contents: read + +# Cancel superseded runs of a PR; never cancel runs on main. +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +jobs: + test: + runs-on: ${{ matrix.os }} + defaults: + run: + # -e: a custom shell gets no errexit, so without it a multi-command step + # (e.g. "Test") would only report the exit status of its last command. + shell: bash -el {0} + strategy: + fail-fast: false + matrix: + os: ["ubuntu-latest", "macos-latest", "windows-latest"] + source: ["conda-forge"] + # os: ["ubuntu-latest"] + # source: ["source"] + # A trailing "t" means the free-threaded (no-GIL) build of that version. + # TODO: add "3.15t" once conda-forge builds cffi and numpy for cp315t. + python-version: ["3.11", "3.12", "3.13", "3.14", "3.14t", "3.15"] + steps: + - name: Checkout + uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + fetch-depth: 0 + persist-credentials: false + - name: Compose conda environment file + env: + PYVER: ${{ matrix.python-version }} + run: | + # conda-forge ships two ABIs for CPython 3.13+ ("cp314" and "cp314t"), + # and `python=3.14` alone lets the solver pick either one: it resolved + # to free-threaded on Linux and Windows but to the GIL build on macOS. + # The `python-gil` and `python-freethreading` metapackages pin + # `python_abi` to one or the other, so ask for the one this matrix + # entry wants instead of leaving it to the solver. + pyver=$PYVER + if [[ $pyver == *t ]]; then + variant=python-freethreading + pyver=${pyver%t} + else + variant=python-gil + fi + cp continuous_integration/environment.yml environment-ci.yml + echo " - python=$pyver" >> environment-ci.yml + echo " - $variant" >> environment-ci.yml + cat environment-ci.yml + - name: Conda + uses: conda-incubator/setup-miniconda@be893c923ea9cf1cf7cd510fbdde27c7e18cbdcb # v4.1.0 + with: + auto-update-conda: true + environment-file: environment-ci.yml + channels: conda-forge,nodefaults + channel-priority: strict + activate-environment: suitesparse-graphblas + auto-activate-base: false + - name: GraphBLAS (from conda-forge) + if: (contains(matrix.source, 'conda-forge')) + run: | + conda install "graphblas=$(cat GB_VERSION.txt)" + - name: GraphBLAS (from source) + if: (contains(matrix.source, 'source')) + run: | + # From release (also works with beta versions) + GRAPHBLAS_PREFIX="${CONDA_PREFIX}" bash suitesparse.sh "refs/tags/$(cat GB_VERSION.txt).0" + + # From tag + # curl -L https://github.com/DrTimothyAldenDavis/GraphBLAS/archive/refs/tags/v$(cat GB_VERSION.txt).tar.gz | tar xzf - + # pushd GraphBLAS-$(cat GB_VERSION.txt)/build + + # From branch + # curl -L https://github.com/DrTimothyAldenDavis/GraphBLAS/tarball/$(cat GB_VERSION.txt) | tar xzf - + # pushd DrTim*/build + + # echo ${CONDA_PREFIX} + # cmake -DJITINIT=2 -DCMAKE_INSTALL_PREFIX=${CONDA_PREFIX} -DCMAKE_INSTALL_LIBDIR=lib -DCMAKE_BUILD_TYPE=Release .. + # cat Makefile + # make all JOBS=16 + # make install + # popd + - name: Build + run: | + pip install -e . --no-deps + - name: Configure coverage + run: | + # Cython's coverage plugin (see [tool.coverage.run] in pyproject.toml) + # needs coverage's C tracer. Where conda-forge has no compiled build of + # coverage for a Python (3.15, for now), it installs a pure-Python build + # that lacks the tracer. There, loading the plugin raises ImportError and + # every `coverage run` dies before it runs anything, so run the tests + # directly instead. + if python -c "import Cython.Coverage" 2>/dev/null; then + coverage erase + echo "COV=coverage run -a --branch" >> "$GITHUB_ENV" + else + echo "Cython coverage plugin unusable here; running without coverage" + python -VV + echo "COV=python" >> "$GITHUB_ENV" + fi + - name: Test + env: + CYTHON_COVERAGE: true + run: | + pytest -s -k test_print_jit_config + $COV -m pytest + $COV suitesparse_graphblas/tests/test_initialize.py + - name: create_headers.py check + if: (! contains(matrix.os, 'windows')) + run: | + $COV suitesparse_graphblas/create_headers.py + git diff --exit-code # error if anything changed diff --git a/.github/workflows/update_graphblas.yml b/.github/workflows/update_graphblas.yml new file mode 100644 index 0000000..f5c0fb6 --- /dev/null +++ b/.github/workflows/update_graphblas.yml @@ -0,0 +1,63 @@ +# Checks for latest SuiteSparse:GraphBLAS version on GitHub and creates a PR to update the version used by this repo. +name: Check for GraphBLAS updates + +permissions: {} + +on: + # Note: Workflow must run at least once to appear in workflows list. + # Push to the bot's branch to trigger workflow. + push: + branches: [ auto_update_gb_version ] + + # Note: Workflow must exist in main branch for workflow dispatch option to appear + workflow_dispatch: + + # Enable cron to check for updates once a day: +# schedule: +# - cron: '0 0 * * *' + +jobs: + gb_version_check: + name: Check for GraphBLAS update + if: github.repository == 'GraphBLAS/python-suitesparse-graphblas' || github.repository == 'alugowski/python-suitesparse-graphblas' + runs-on: ubuntu-latest + # In addition to these permissions, must explicitly allow GitHub Actions to create pull requests. + # This setting can be found in a repository's settings under Actions > General > Workflow permissions. + # https://github.com/peter-evans/create-pull-request#workflow-permissions + permissions: + contents: write + pull-requests: write + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + fetch-depth: 0 + persist-credentials: false + + - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0 + with: + python-version: "3.11" + + - name: Get latest GraphBLAS version + run: | + python latest_suitesparse_graphblas_version.py > GB_VERSION.txt + echo "GB_VERSION=$(cat GB_VERSION.txt)" >> "$GITHUB_ENV" + shell: bash + + - name: Create Pull Request + uses: peter-evans/create-pull-request@5f6978faf089d4d20b00c7766989d076bb2fc7f1 # v8.1.1 + with: + # See documentation: https://github.com/peter-evans/create-pull-request + # Action behavior: https://github.com/peter-evans/create-pull-request#action-behaviour + # TL;DR: create a PR if there is a diff and keep it up to date with changes as they arrive. + # + # To trigger tests with this PR set up a Personal Access Token as in the docs above. +# token: ${{ secrets.PAT }} + add-paths: GB_VERSION.txt + commit-message: Update to GraphBLAS ${{ env.GB_VERSION }} + title: Update to SuiteSparse:GraphBLAS ${{ env.GB_VERSION }} + body: | + Auto-generated by `update_graphblas.yml` + + Close then reopen this PR to trigger tests. See [here](https://github.com/peter-evans/create-pull-request/blob/main/docs/concepts-guidelines.md#triggering-further-workflow-runs) for why automatic triggers do not work. + branch: auto_update_gb_version + delete-branch: true diff --git a/.github/workflows/wheels.yml b/.github/workflows/wheels.yml new file mode 100644 index 0000000..818e255 --- /dev/null +++ b/.github/workflows/wheels.yml @@ -0,0 +1,271 @@ +name: Python wheel package build and publish + +on: + release: + types: [published] + + # Enable Run Workflow button in GitHub UI + workflow_dispatch: + inputs: + # Manual dispatch allows optional upload of wheels to PyPI + upload_dest: + type: choice + description: Upload wheels to + options: + - No Upload + - PyPI + - Test PyPI + + push: + branches: [ main ] + + pull_request: + +# Cancel superseded runs of a PR only. Keying on `github.ref` would also let a +# push to main cancel a running release or manual (workflow_dispatch) upload. +concurrency: + group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.run_id }} + cancel-in-progress: true + +permissions: + contents: read + +jobs: + build_sdist: + name: Build SDist + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + fetch-depth: 0 + persist-credentials: false + + - name: Build SDist + run: pipx run build --sdist + + - name: Check metadata + run: pipx run twine check dist/* + + - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: sdist + path: dist/*.tar.gz + + + build_wheels: + name: Wheels - ${{ matrix.cibw_archs }} ${{ matrix.arch_note}} - ${{ matrix.os }} + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + include: + - os: windows-latest + cibw_archs: "auto64" + # No PyPy: NumPy has no wheels for PyPy 8.0, and a NumPy built from source here + # uses MinGW, which warns on import that it is experimental ("CRASHES ARE TO BE + # EXPECTED"), failing the tests. + cibw_skip: "pp*" + + # Linux x86_64 manylinux + - os: ubuntu-latest + cibw_archs: "x86_64" + # manylinux_2_28 uses dnf (not yum). libffi-devel needed for Python 3.12+ cffi. + cibw_before_build_linux: "dnf install -y libffi-devel || yum install -y libffi-devel || true" + # skip musllinux + cibw_skip: "*musl*" + + # Linux x86_64 musllinux + # Separate runner for a Musl build of graphblas. The glibc build is not guaranteed to be compatible. + - os: ubuntu-latest + cibw_archs: "x86_64" + arch_note: "musl" + # skip manylinux (built elsewhere) + cibw_skip: "*many*" + + # Linux aarch64 — native ARM runner (no QEMU emulation needed) + - os: ubuntu-24.04-arm + cibw_archs: "auto" + # numpy wheels not available for aarch64 musllinux + cibw_skip: "*musl*" + + # macOS x86_64 — macos-15-intel is the last Intel macOS runner. + # libomp from Homebrew determines the minimum supported macOS version. + - os: macos-15-intel + cibw_archs: "x86_64" + + # macOS Apple Silicon + # Keep runner version as old as possible: libomp determines minimum macOS version. + # macos-14 is retired on 2026-11-02 (and fails jobs during brownouts before then). + - os: macos-15 + cibw_archs: "arm64" + + # WebAssembly for Pyodide (PEP 783 `pyemscripten_*` wheels). GraphBLAS is built in + # before-build (see CIBW_*_PYODIDE below). + - os: ubuntu-latest + cibw_platform: "pyodide" + cibw_archs: "wasm32" + arch_note: "pyodide" + # Pyodide for 3.15 is an alpha, and building for it names the cffi module with + # the build machine's abi3 suffix (e.g., `_graphblas.abi3-x86_64-linux-gnu.so`), + # which Pyodide can't import. + cibw_skip: "cp315-*" + + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + with: + fetch-depth: 0 + persist-credentials: false + + - name: Setup for testing + if: github.event_name == 'push' || github.event_name == 'pull_request' + # Ask suitesparse.sh to compile in the fastest way possible and provide a GB version to build + run: | + echo "SUITESPARSE_FASTEST_BUILD=1" >> "$GITHUB_ENV" + shell: bash + + - name: Setup GraphBLAS version from GB_VERSION.txt + # Use GraphBLAS version specified in GB_VERSION.txt unless specified in a git tag (next workflow step). + # Git tag method required for uploads to PyPI. + if: github.event_name != 'release' && github.event.inputs.upload_dest != 'PyPI' + run: echo "GB_VERSION_REF=refs/tags/$(cat GB_VERSION.txt).0" >> "$GITHUB_ENV" + shell: bash + + - name: Setup GraphBLAS version from git tag + if: ${{ startsWith(github.ref, 'refs/tags/') }} + # If this is a tagged ref, like a release, then use the tag for the graphblas version + run: echo "GB_VERSION_REF=$GITHUB_REF" >> "$GITHUB_ENV" + shell: bash + + - name: Install tools (macOS) + if: contains(matrix.os, 'macos') + # Install coreutils which includes `nproc` used by `make -j` in suitesparse.sh + # + # Explicitly install libomp to be clear about the dependency. + # + # libomp determines the minimum macOS version that we can build for + run: | + brew fetch --retry coreutils && brew install coreutils + brew fetch --retry libomp && brew reinstall libomp + echo "MACOSX_DEPLOYMENT_TARGET=$(otool -l "$(brew --prefix libomp)/lib/libomp.dylib" | grep minos | awk '{print $2}')" >> "$GITHUB_ENV" + + - uses: pypa/cibuildwheel@8c2dcd2e96041a619f5ff03c9638d7941e2553a4 # v4.3.3 + with: + output-dir: wheelhouse + env: + # very verbose + CIBW_BUILD_VERBOSITY: 3 + + # PyPy is not built by default (since cibuildwheel v3); enable explicitly. + # cibuildwheel v4.3 builds PyPy 8.0, whose ABI tag (`pypy311_pp80`) PyPy 7.3 can't + # install, and NumPy has no wheels for it, so building and testing compile NumPy. + # Free-threaded wheels (cp314t, cp315t) are built and tested by default. + # cibuildwheel v4 dropped cp313t (and its "cpython-freethreading" + # enable option) entirely. + CIBW_ENABLE: "pypy" + + CIBW_PLATFORM: ${{ matrix.cibw_platform || 'auto' }} + + # Build SuiteSparse + CIBW_BEFORE_ALL: bash suitesparse.sh ${{ env.GB_VERSION_REF }} + + CIBW_BEFORE_BUILD_LINUX: ${{ matrix.cibw_before_build_linux }} + + # Pyodide: cibuildwheel sets up Emscripten for each Python version (each Pyodide + # version has its own) after before-all, so build GraphBLAS in before-build instead. + # SUITESPARSE_EMSCRIPTEN=1 asks suitesparse.sh for a static library to link into the + # extension module. The empty before-all overrides the one above. + # EMCC_CFLAGS=-O2: Pyodide links with -Oz, and binaryen's wasm-opt -Oz had not + # finished with GraphBLAS after 30 CPU-minutes; -O2 takes about a minute. emcc + # appends EMCC_CFLAGS to every command, so its -O2 is the one that counts (also for + # compiling GraphBLAS, which is then smaller and no slower). + CIBW_BEFORE_ALL_PYODIDE: "" + CIBW_BEFORE_BUILD_PYODIDE: bash suitesparse.sh ${{ env.GB_VERSION_REF }} + CIBW_ENVIRONMENT_PYODIDE: SUITESPARSE_EMSCRIPTEN=1 GRAPHBLAS_PREFIX=/tmp/graphblas-wasm GraphBLAS_ROOT=/tmp/graphblas-wasm EMCC_CFLAGS=-O2 + + CIBW_ENVIRONMENT_PASS_LINUX: SUITESPARSE_FASTEST_BUILD + + # CMAKE_GNUtoMS=ON asks suitesparse.sh to build libraries in MSVC style on Windows. + CIBW_ENVIRONMENT_WINDOWS: CMAKE_GNUtoMS=ON GRAPHBLAS_PREFIX="C:/GraphBLAS" + + # macOS libomp requires special configs. BREW_LIBOMP=1 asks suitesparse.sh to include them. + # SUITESPARSE_MACOS_ARCH asks to build a particular architecture. Either x86 or arm64. + CIBW_ENVIRONMENT_MACOS: BREW_LIBOMP="1" SUITESPARSE_MACOS_ARCH=${{ matrix.cibw_archs }} + + # Uncomment to only build CPython wheels + # CIBW_BUILD: "cp*" + + # Architectures to build specified in matrix + CIBW_ARCHS: ${{ matrix.cibw_archs }} + + # Skip PyPy 3.12 everywhere: no NumPy release builds on it yet (NumPy's bundled + # pythoncapi_compat.h redefines functions that PyPy 3.12 v8.0's headers declare). + CIBW_SKIP: "pp312-* ${{ matrix.cibw_skip }}" + + # Use delvewheel on Windows. + # This copies graphblas.dll into the wheel. "repair" in cibuildwheel parlance includes copying any shared + # libraries from the build host into the wheel to make the wheel self-contained. + # cibuildwheel v4 installs delvewheel and uses it by default; this overrides its command so it can + # find graphblas.dll and to apply a workaround: --no-mangle instead of stripping graphblas.dll + # see https://github.com/adang1345/delvewheel/issues/33 + CIBW_REPAIR_WHEEL_COMMAND_WINDOWS: "delvewheel repair --add-path \"C:\\GraphBLAS\\bin\" --no-mangle \"libgomp-1.dll;libgcc_s_seh-1.dll\" -w {dest_dir} {wheel}" + + # make cibuildwheel install test dependencies from pyproject.toml + CIBW_TEST_EXTRAS: "test" + + # run tests. They run from a temporary directory, so pyproject.toml's pytest + # config doesn't apply; -W error restores its `filterwarnings = ["error"]`. + # `python -m pytest`, because the `pytest` script doesn't work in a Pyodide venv. + CIBW_TEST_COMMAND: "python -m pytest --pyargs suitesparse_graphblas -s -k test_print_jit_config && python -m pytest -v -W error --pyargs suitesparse_graphblas" + + - uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2 + with: + name: wheels-${{ matrix.os }}-${{ matrix.cibw_archs }}${{ matrix.arch_note}} + path: wheelhouse/*.whl + if-no-files-found: error + + + # Uploads use PyPI Trusted Publishing (no API token). Each index trusts this workflow + # (wheels.yml) only when it runs in the GitHub environment registered with it. + upload_pypi: + name: Upload to PyPI + needs: [build_wheels, build_sdist] + runs-on: ubuntu-latest + # only upload releases (or an explicit manual request) to PyPI + if: github.repository == 'GraphBLAS/python-suitesparse-graphblas' && ((github.event_name == 'release' && github.event.action == 'published') || (github.event_name == 'workflow_dispatch' && github.event.inputs.upload_dest == 'PyPI')) + environment: + name: pypi + url: https://pypi.org/p/suitesparse-graphblas + permissions: + id-token: write # for Trusted Publishing (and its attestations) + steps: + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 + with: + path: dist + merge-multiple: true + + - uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3 + with: + # PyPI does not allow replacing a file. Without this flag the entire action fails if even a single duplicate exists. + skip-existing: true + + upload_test_pypi: + name: Upload to Test PyPI + needs: [build_wheels, build_sdist] + runs-on: ubuntu-latest + if: github.repository == 'GraphBLAS/python-suitesparse-graphblas' && github.event_name == 'workflow_dispatch' && github.event.inputs.upload_dest == 'Test PyPI' + environment: + name: test-pypi + url: https://test.pypi.org/p/suitesparse-graphblas + permissions: + id-token: write # for Trusted Publishing (and its attestations) + steps: + - uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2 + with: + path: dist + merge-multiple: true + + - uses: pypa/gh-action-pypi-publish@7245906fb61fa33a13554f9d5fb856fe61758086 # v1.14.3 + with: + repository-url: https://test.pypi.org/legacy/ + # PyPI does not allow replacing a file. Without this flag the entire action fails if even a single duplicate exists. + skip-existing: true diff --git a/.gitignore b/.gitignore index 2b09537..7d098cf 100644 --- a/.gitignore +++ b/.gitignore @@ -4,7 +4,9 @@ __pycache__/ *$py.class # C extensions +*.c *.so +*.dll # Distribution / packaging .Python @@ -26,6 +28,14 @@ share/python-wheels/ .installed.cfg *.egg MANIFEST +wheelhouse + +# Wheel building stuff +GraphBLAS-*/ + +# Left behind by create_headers.py +suitesparse_graphblas/GraphBLAS-orig.h +suitesparse_graphblas/GraphBLAS-processed.h # PyInstaller # Usually these files are written by a python script from a template @@ -37,6 +47,9 @@ MANIFEST pip-log.txt pip-delete-this-directory.txt +# Conda environment file composed by CI (see .github/workflows/test.yml) +environment-ci.yml + # Unit test / coverage reports htmlcov/ .tox/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..86cebb5 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,116 @@ +# https://pre-commit.com/ +# +# Before first use: `pre-commit install` +# To run: `pre-commit run --all-files` +# To update: `pre-commit autoupdate` +# - &flake8_dependencies below needs updated manually +fail_fast: true +default_language_version: + python: python3 +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: check-added-large-files + - id: check-case-conflict + - id: check-executables-have-shebangs + - id: check-illegal-windows-names + - id: check-merge-conflict + - id: check-ast + - id: check-toml + - id: check-yaml + - id: check-vcs-permalinks + - id: debug-statements + - id: destroyed-symlinks + - id: detect-private-key + - id: forbid-submodules + - id: end-of-file-fixer + - id: mixed-line-ending + args: [--fix=lf] + - id: trailing-whitespace + - id: name-tests-test + args: ["--pytest-test-first"] + - repo: https://github.com/abravalheri/validate-pyproject + rev: '0.26' + hooks: + - id: validate-pyproject + name: Validate pyproject.toml + - repo: https://github.com/PyCQA/autoflake + rev: v2.4.0 + hooks: + - id: autoflake + args: [--in-place] + - repo: https://github.com/pycqa/isort + rev: 9.0.2 + hooks: + - id: isort + - repo: https://github.com/asottile/pyupgrade + rev: v3.22.0 + hooks: + - id: pyupgrade + args: [--py311-plus] + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 26.10.1 + hooks: + - id: black + - repo: https://github.com/PyCQA/flake8 + rev: 7.4.1 + hooks: + - id: flake8 + args: ["--config=.flake8"] + additional_dependencies: &flake8_dependencies + # These versions need updated manually + - flake8==7.4.1 + - flake8-comprehensions==3.17.0 + - flake8-bugbear==26.9.30 + # - flake8-simplify==0.22.0 + - repo: https://github.com/asottile/yesqa + rev: v1.5.0 + hooks: + - id: yesqa + additional_dependencies: *flake8_dependencies + # `pyroma` may help keep our package standards up to date if best practices change. + # This is a "low value" check though and too slow to run as part of pre-commit. + # - repo: https://github.com/regebro/pyroma + # rev: "5.0.1" + # hooks: + # - id: pyroma + # args: [-n, "10", .] + - repo: https://github.com/shellcheck-py/shellcheck-py + rev: "v0.11.0.1-1" + hooks: + - id: shellcheck + - repo: https://github.com/pre-commit/pygrep-hooks + rev: v1.10.0 + hooks: + - id: python-check-blanket-noqa + - id: python-check-blanket-type-ignore + - id: python-no-eval + - id: python-no-log-warn + - id: text-unicode-replacement-char + - repo: https://github.com/rhysd/actionlint + rev: v1.7.12 + hooks: + - id: actionlint + - repo: https://github.com/zizmorcore/zizmor-pre-commit + rev: v1.31.1 + hooks: + - id: zizmor + - repo: https://github.com/python-jsonschema/check-jsonschema + rev: 0.38.2 + hooks: + - id: check-dependabot + - id: check-github-workflows + - repo: https://github.com/pysentry/pysentry-pre-commit + rev: v0.5.0 + hooks: + - id: pysentry + args: ["--format=human", "--fail-on=low", "--sources=pypa,osv,pypi"] + - repo: meta + hooks: + - id: check-hooks-apply + - id: check-useless-excludes + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v6.0.0 + hooks: + - id: no-commit-to-branch # no commit directly to main diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..aeaf36c --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,227 @@ +# AGENTS.md + +This file provides guidance to AI coding agents (e.g., Claude Code) when working with code in this repository. + +## What this package is + +`suitesparse-graphblas` is a low-level Python CFFI binding around the C library +[SuiteSparse:GraphBLAS](https://github.com/DrTimothyAldenDavis/GraphBLAS). It exposes the +raw `ffi` and `lib` symbols and, on top of them, a **functional API** in the +`suitesparse_graphblas.api` package (`matrix`, `vector`, `scalar`, plus `binaryop`, `monoid`, +`semiring`, `descriptor`, `iterator`, …). `matrix`, `vector`, and `scalar` (also re-exported as +`suitesparse_graphblas.matrix` etc. for backward compatibility) are the **main entry point for +users of this library directly** — they are module-level functions operating on opaque CFFI +handles, e.g. `A = matrix.matrix_new(lib.GrB_BOOL, 3, 3); matrix.set_bool(A, True, 2, 2)`. Higher-level +syntax wrappers ([python-graphblas](https://github.com/python-graphblas/python-graphblas) +and [pygraphblas](https://github.com/Graphegon/pygraphblas)) build on top of this same +package for users who want a more Pythonic, OO-style interface. + +The currently targeted SuiteSparse:GraphBLAS version is pinned in `GB_VERSION.txt`. + +## Building from source + +Building requires a working SuiteSparse:GraphBLAS C library on the system. Point at it via +`GraphBLAS_ROOT` (must contain `include/GraphBLAS.h` and `lib/`): + +```bash +export GraphBLAS_ROOT="/path/to/graphblas" # or `$(brew --prefix suitesparse)` on macOS +pip install -e . --no-deps # editable dev install +``` + +If `GraphBLAS_ROOT` is unset, the build falls back to: +- `C:\GraphBLAS` on Windows +- `/usr/local` if `/usr/local/include/suitesparse` exists (the path used by `suitesparse.sh`) +- `sys.prefix` (works for conda-installed `graphblas`) + +The CI build uses conda-forge `graphblas=$(cat GB_VERSION.txt)`. To build SuiteSparse from +source instead, run `bash suitesparse.sh refs/tags/$(cat GB_VERSION.txt).0`. That script also +honors `SUITESPARSE_FAST_BUILD` / `SUITESPARSE_FASTEST_BUILD` env vars to disable many type +specializations for much faster local builds. + +### WebAssembly (Pyodide) + +`wheels.yml` builds `pyemscripten` wheels for Pyodide with cibuildwheel +(`CIBW_PLATFORM=pyodide`). With `SUITESPARSE_EMSCRIPTEN=1`, `suitesparse.sh` builds GraphBLAS +as a static library (no OpenMP: Pyodide has no threads) with `emcmake` and Pyodide's compiler +flags, so `emcc` and `pyodide` must be on `PATH`; cibuildwheel provides them only in +before-build, once per Python. Two things that native builds forgive break on wasm32: + +- Calling a C function through a pointer of the wrong type traps ("function signature + mismatch"), so each function pointer type in `utils.pxd`/`utils.pyx` must match the + function's C declaration exactly, return type included (10.5.1.0 typed `GxB_init` as + returning `uint64_t`, which fails on import there). +- NumPy's default integer is int32, so give `dtype=np.int64` to arrays that GraphBLAS reads as + `GrB_INT64`. + +## Tests, lint, and other commands + +Testing requires the compiled CFFI extension and the SuiteSparse:GraphBLAS C library, so +tests should be run inside the Docker container. Build the image once (this compiles +GraphBLAS from source and takes several minutes), then run tests against it: + +```bash +# Build the test image (uses the psg stage which includes pytest) +docker build --target psg \ + --build-arg SUITESPARSE=v$(cat GB_VERSION.txt) \ + --build-arg VERSION=99.0.0.0 \ + -t psg-test . + +# Run the full test suite (unit tests + all doctests) +docker run --rm -w /tmp psg-test pytest --pyargs suitesparse_graphblas --doctest-modules -v + +# Run only the unit tests (no doctests) +docker run --rm -w /tmp psg-test pytest --pyargs suitesparse_graphblas.tests -v + +# Run a single test file +docker run --rm -w /tmp psg-test pytest --pyargs suitesparse_graphblas.tests.test_scalar -v + +# Run by test name substring +docker run --rm -w /tmp psg-test pytest --pyargs suitesparse_graphblas --doctest-modules -k test_print_jit_config -v + +# Run linters/formatters (locally, no C library needed) +pre-commit run --all-files +``` + +Rebuild the Docker image after making changes — the `ADD . /psg` layer picks up the +current working tree. The SuiteSparse compilation layer is cached so rebuilds are fast. + +`conftest.py` calls `suitesparse_graphblas.initialize()` once per session — `GrB_init` may +only be called once per process, so `test_initialize.py` is run as a separate process in CI: + +```bash +docker run --rm -w /tmp psg-test python3 -m suitesparse_graphblas.tests.test_initialize +``` + +Coverage runs in CI use `CYTHON_COVERAGE=true` so the Cython `utils.pyx` extension is +recompiled with line tracing. + +## Architecture: how the binding is generated and assembled + +There are two layers of generated code, and understanding them is essential before touching +anything related to types, defines, or the FFI surface. + +### 1. Header generation — `suitesparse_graphblas/create_headers.py` + +This script regenerates **`suitesparse_graphblas.h`**, **`suitesparse_graphblas_no_complex.h`**, +and **`source.c`** from an upstream `GraphBLAS.h`. It: + +- Copies `GraphBLAS.h` from the install, runs the C preprocessor (using pycparser's + `fake_libc_include`), and parses the result with pycparser. +- Emits a cleaned-up header that cffi can `cdef()`, plus a complex-free variant for + platforms (notably MSVC) where `_Complex` types don't work. +- Manually tracks `DEFINES`, `CHAR_DEFINES`, `IGNORE_DEFINES`, and `DEPRECATED` sets. + **When updating to a new SuiteSparse:GraphBLAS version, these lists are the things most + likely to need editing.** New macros, new deprecations, or removed symbols all flow + through here. +- CI runs this script and `git diff --exit-code` to fail the build if the committed headers + drift from upstream. Re-running it locally and committing the result is the standard fix. + +### 2. CFFI compilation — `build_graphblas_cffi.py` + +`ffibuilder` calls `set_source()` with `source.c` and `cdef()` with `suitesparse_graphblas.h` +to produce the compiled extension `suitesparse_graphblas._graphblas` (which exposes `ffi` +and `lib`). On Windows it instead emits a `_graphblas.c` file and runs a textual patch +(`float _Complex` → `_Fcomplex`, `double _Complex` → `_Dcomplex`, `-DGxB_HAVE_COMPLEX_MSVC`) +because cffi cannot represent MSVC's complex types — see `get_extension()` for the patching +logic. `setup.py` chooses between the cffi-driven and Extension-driven paths based on +`build_graphblas_cffi.is_win`. + +`setup.py` also cythonizes any `*.pyx` under `suitesparse_graphblas/` (currently +`utils.pyx`). When Cython is unavailable, it falls back to checked-in `*.c` files; the +build will refuse to proceed if any are missing. + +### 3. Python layer (`suitesparse_graphblas/__init__.py` and friends) + +The package re-exports `ffi`/`lib` from the compiled extension and adds only thin helpers: + +- `initialize(blocking=False, memory_manager="numpy")` — must be called exactly once before + any GraphBLAS calls. The `numpy` memory manager routes allocation through + `PyDataMem_NEW`/`FREE` (defined in `utils.pyx::call_gxb_init`) so buffers can be claimed + zero-copy by NumPy and tracked by `tracemalloc`. +- `check_status(obj, info)` — central error handler. Maps `GrB_Info` codes to exception + classes in `exceptions.py` and pulls the human-readable message via the type-specific + `*_error()` function, looked up by cdata cname in `_error_func_lookup`. +- `vararg(val)` — a workaround for variadic GraphBLAS calls on `osx-arm64` and `ppc64le` + where ARM64 calling conventions force variadic args onto the stack. Prefer the + non-variadic typed variants (e.g. `GxB_Matrix_Option_get_INT32`) when they exist. +- `libget(name)` — fallback that retries a `GrB_*` lookup as `GxB_*` when SuiteSparse moves + a symbol between standard and extension namespaces. +- `burble` — context manager / global toggle for `GxB_BURBLE` diagnostic output. +- `api/matrix.py`, `api/vector.py`, `api/scalar.py` (and the other `api/` modules) — + **the functional API** of the package, and the primary user-facing surface for code that + uses `suitesparse-graphblas` directly. `__init__.py` re-exports `matrix`, `vector`, + `scalar`, and `iterator` at the bottom of the file (to avoid a circular import) so + `suitesparse_graphblas.matrix` keeps working. Each module follows the same convention: + `._new(...)` (e.g. `matrix.matrix_new`) returns an `ffi.gc`-managed + cdata handle (`GrB_Matrix*`, `GrB_Vector*`, or `GxB_Scalar*`) and every other function + takes that handle as its first argument and routes errors through `check_status`. The + design is deliberately functional rather than class-based so the same handles can be + passed through higher-level wrappers without object-identity friction. When adding + features to this package, this is the layer where new user-facing helpers belong. +- `api/io/serialize.py`, `api/io/binary.py` — supporting I/O helpers (compressed serialize / + deserialize, binary format read/write), also importable as `suitesparse_graphblas.io`. + `api/matrix.py` and `api/vector.py` already re-export `serialize` / `deserialize` from + `api/io/serialize.py` so callers can reach them as `matrix.serialize(A)` etc. + +### 4. `utils.pyx` and free-threading + +The Cython module exists to (a) call `GxB_init` with NumPy's allocators by casting the cffi +function pointer through `uintptr_t` into a real C function pointer, and (b) move buffers +between GraphBLAS and NumPy without copying. Its module docstring is the reference for (b). + +Memory that changes owner must be freed by the allocator that allocated it. GraphBLAS frees +with the allocator of the buffer's *arena* (arena 0 is NumPy's `PyDataMem_*` allocator for +`memory_manager="numpy"`, libc's for `"c"`; `GxB_arena_init` adds more). NumPy frees with +the array's memory handler (NEP 49), or with libc `free` if it has none. Don't assume any +two of these agree: with NumPy ≥ 2.5, NumPy's allocator is `PyMem_RawMalloc`, which is +mimalloc on free-threaded Python ≥ 3.15 and gains debug hooks under `python -X dev`. So, +per arena, `utils.pyx` asks GraphBLAS for the arena's functions and uses NumPy's default +handler if they are NumPy's, else its own handler that calls them +(`suitesparse_graphblas_arena`): + +- GraphBLAS → NumPy: `claim_buffer` / `claim_buffer_2d` attach that handler. +- NumPy → GraphBLAS: use `give_buffer` (a context manager) around the GraphBLAS call that + takes ownership (`GxB_*_pack_*`, `GxB_*_load` with `GrB_DEFAULT + arena`, ...). It hands + over the array itself only if `can_unclaim_buffer` (owns its data, writeable, and its + handler is the arena's), otherwise a copy in `empty(...)` memory, and it commits only if + GraphBLAS set the pointer to NULL. Never hand GraphBLAS libc `malloc` memory or arrays of + unknown provenance; `api/io/binary.py::binread` shows the pattern. +- `arena` defaults to the *global* data arena. GraphBLAS itself uses the data arena of the + Context engaged on the calling thread, which can't be queried, so code that must be right + under any Context names the arena: `serialize_*` call `GxB_*_serialize_arena`, and + `binread` uses the data arena of the matrix it just created. `GxB_*_unpack_*` and + `GxB_*_export_*` move the object to that arena before handing out its arrays, so the arena + an object was made in says nothing about them. + +`tests/test_memory.py` checks all of this (both managers, a libc arena as an explicit, +global, and Context arena, threads, `binread`) in a subprocess under `PYTHONMALLOC=debug`, +which turns a mismatch into an abort on any Python. Its buffers are over 1024 bytes on +purpose: NumPy caches smaller freed blocks, which hides a wrong free. `conftest.py` also +makes NumPy warn, failing the test, whenever it frees an array that owns its data but has +no memory handler; that catches a missing handler even where the allocators happen to agree. + +When claiming a buffer from `GxB_*_unload`, use the arena in the returned `handling` +(`handling - GrB_DEFAULT`), and never claim one with `handling >= GxB_IS_READONLY`: whoever +loaded it read-only still owns it. + +The file is marked `freethreading_compatible=True`. The package does nothing special for +free-threading itself — correctness depends on SuiteSparse:GraphBLAS being thread-safe, +which it is required to be. + +## Style and tooling + +- Black, isort, flake8 (config in `.flake8`, line length 100, double quotes), pyupgrade + (`--py311-plus`), autoflake, shellcheck — all wired through `pre-commit`. Run + `pre-commit run --all-files` before pushing. +- `pre-commit` also lints GitHub Actions workflows (actionlint, zizmor) and scans + dependencies for known vulnerabilities (pysentry). actionlint runs shellcheck on `run:` + scripts only when `shellcheck` is on `PATH` — it is on the CI runner, so quote `$(...)` + and `"$GITHUB_ENV"` even if it passes locally. Don't expand `${{ ... }}` contexts inside + `run:` scripts (zizmor's template-injection audit); pass them through `env:` instead. +- `pre-commit` also blocks direct commits to `main`. +- pytest is strict (see `[tool.pytest.ini_options]`): warnings are errors, markers must be + registered, and xfails must fail. +- Python ≥ 3.11. NumPy ≥ 2.0 is required at build time (CFFI extension), ≥ 1.24 at runtime. +- Generated headers (`suitesparse_graphblas.h`, `suitesparse_graphblas_no_complex.h`, + `source.c`) are checked in and **must be regenerated via `create_headers.py`** rather + than hand-edited. CI enforces this. diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..e20d1b6 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,71 @@ +ARG BASE_CONTAINER=python:3.12-slim-bookworm +FROM ${BASE_CONTAINER} AS suitesparse +ENV DEBIAN_FRONTEND=noninteractive + +RUN apt-get update && apt-get install -yq build-essential cmake git + +ARG SUITESPARSE +ARG COMPACT=0 + +WORKDIR /build +RUN git clone https://github.com/eliben/pycparser.git --depth 1 + +# Use `-DJITINIT=2` so that the JIT functionality is available, but disabled by default. +# Level 2, "run", means that pre-JIT kernels may be used, which does not require a compiler at runtime. +# Disable JIT entirely to avoid segfaulting in tests (matches CI in suitesparse.sh). +RUN git clone https://github.com/DrTimothyAldenDavis/GraphBLAS.git --depth 1 --branch ${SUITESPARSE} \ + && cd GraphBLAS/build \ + && cmake .. \ + -DCMAKE_BUILD_TYPE=Release \ + -DCMAKE_INSTALL_PREFIX=/usr \ + -DCOMPACT=${COMPACT} \ + -DJITINIT=2 \ + -DGRAPHBLAS_USE_JIT=OFF \ + && make -j$(nproc) \ + && make install + +FROM ${BASE_CONTAINER} AS psg +ARG VERSION +ENV PYTHONUNBUFFERED=1 + +COPY --from=suitesparse /usr/include/suitesparse/GraphBLAS.h /usr/local/include/suitesparse/GraphBLAS.h +# Copy only the real versioned library; recreate symlinks (Docker COPY collapses cross-stage symlinks). +COPY --from=suitesparse /usr/lib/x86_64-linux-gnu/libgraphblas.so.*.*.* /usr/lib/x86_64-linux-gnu/ +RUN cd /usr/lib/x86_64-linux-gnu \ + && REAL=$(ls libgraphblas.so.*.*.*) \ + && SOMAJOR=libgraphblas.so.$(echo "$REAL" | sed -E 's/libgraphblas\.so\.([0-9]+).*/\1/') \ + && ln -sf "$REAL" "$SOMAJOR" \ + && ln -sf "$SOMAJOR" libgraphblas.so \ + && ldconfig + +RUN apt-get update && apt-get install -yq build-essential git +RUN pip3 install --break-system-packages numpy cffi pytest cython pycparser setuptools wheel setuptools-git-versioning + +COPY --from=suitesparse /build/pycparser/utils/fake_libc_include/* /usr/local/lib/python3.12/site-packages/pycparser/utils/fake_libc_include/ + +RUN mkdir -p /psg +ADD . /psg + +WORKDIR /psg +# `git tag || true` so the build is idempotent when ${VERSION} already matches an existing tag in the source tree. +RUN (git tag ${VERSION} || true) && \ + python3 suitesparse_graphblas/create_headers.py && \ + pip3 install --break-system-packages --no-build-isolation --no-deps . && \ + ldconfig + +#RUN pytest --pyargs suitesparse_graphblas.tests +RUN apt-get -y --purge remove git python3-pip && apt-get clean + +FROM ${BASE_CONTAINER} +COPY --from=suitesparse /usr/lib/x86_64-linux-gnu/libgraphblas.so.*.*.* /usr/lib/x86_64-linux-gnu/ +COPY --from=suitesparse /usr/lib/x86_64-linux-gnu/libgomp.so.*.*.* /usr/lib/x86_64-linux-gnu/ +COPY --from=psg /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages +RUN cd /usr/lib/x86_64-linux-gnu \ + && GBREAL=$(ls libgraphblas.so.*.*.*) \ + && GBSOMAJOR=libgraphblas.so.$(echo "$GBREAL" | sed -E 's/libgraphblas\.so\.([0-9]+).*/\1/') \ + && ln -sf "$GBREAL" "$GBSOMAJOR" \ + && ln -sf "$GBSOMAJOR" libgraphblas.so \ + && GMREAL=$(ls libgomp.so.*.*.*) \ + && GMSOMAJOR=libgomp.so.$(echo "$GMREAL" | sed -E 's/libgomp\.so\.([0-9]+).*/\1/') \ + && ln -sf "$GMREAL" "$GMSOMAJOR" \ + && ldconfig diff --git a/GB_VERSION.txt b/GB_VERSION.txt new file mode 100644 index 0000000..a39233b --- /dev/null +++ b/GB_VERSION.txt @@ -0,0 +1 @@ +10.5.2 diff --git a/LICENSE b/LICENSE index 261eeb9..422684f 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright [yyyy] [name of copyright owner] + Copyright 2021 Anaconda Inc., Graphegon, and contributors Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. diff --git a/MANIFEST.in b/MANIFEST.in new file mode 100644 index 0000000..61cd04d --- /dev/null +++ b/MANIFEST.in @@ -0,0 +1,8 @@ +include setup.py +include build_graphblas_cffi.py +include README.md +include LICENSE +include suitesparse_graphblas/*.pxd +include suitesparse_graphblas/*.pyx +include suitesparse_graphblas/*.c +include suitesparse_graphblas/*.h diff --git a/README.md b/README.md index b10641f..5334701 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,58 @@ # python-suitesparse-graphblas + +[![Version](https://img.shields.io/pypi/v/suitesparse-graphblas.svg)](https://pypi.org/project/suitesparse-graphblas/) +[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://github.com/GraphBLAS/python-suitesparse-graphblas/blob/main/LICENSE) +[![Build Status](https://github.com/GraphBLAS/python-suitesparse-graphblas/workflows/Test/badge.svg)](https://github.com/GraphBLAS/python-suitesparse-graphblas/actions) +[![Code style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black) + Python CFFI Binding around [SuiteSparse:GraphBLAS](https://github.com/DrTimothyAldenDavis/GraphBLAS) This is a base package that exposes only the low level CFFI API bindings and symbols. This package is shared by the syntax bindings [pygraphblas](https://github.com/Graphegon/pygraphblas) and -[grblas](https://github.com/metagraph-dev/grblas). +[python-graphblas](https://github.com/python-graphblas/python-graphblas). + + +## Installation from pre-built wheels +Pre-built wheels for common platforms are available from PyPI and conda. These bundle a compiled copy of SuiteSparse:GraphBLAS. + +```bash +pip install suitesparse-graphblas +``` + +or + +```bash +conda install -c conda-forge python-suitesparse-graphblas +``` + +### In the browser (Pyodide) +PyPI also has WebAssembly wheels for [Pyodide](https://pyodide.org) 314 (Python 3.14) and +0.29.4 or later (Python 3.13), the `pyemscripten` platform of +[PEP 783](https://peps.python.org/pep-0783/). So, in Pyodide or JupyterLite +(jupyterlite-pyodide-kernel 0.8 uses Pyodide 314): + +```python +import micropip +await micropip.install("suitesparse-graphblas") +``` + +Older versions of Pyodide don't recognize these wheels: micropip says it can't find a pure +Python 3 wheel. GraphBLAS runs single-threaded in Pyodide, which has no threads (so no OpenMP). + +## Installation from source +If you wish to link against your own copy of SuiteSparse:GraphBLAS you may build from source. + +Specify the location of your SuiteSparse:GraphBLAS installation in the `GraphBLAS_ROOT` environment variable then use the standard pip build from source mechanism. This location must contain `include/GraphBLAS.h` and `lib/`. + +```bash +export GraphBLAS_ROOT="/path/to/graphblas" +pip install suitesparse-graphblas-*.tar.gz +``` +You may also have to appropriately set `LD_LIBRARY_PATH` to find `libgraphblas` at runtime. + +For example, to use Homebrew's SuiteSparse:GraphBLAS on macOS, with the sdist from PyPI, and with all dependencies using wheels: +```bash +GraphBLAS_ROOT="$(brew --prefix suitesparse)" pip install --no-binary suitesparse-graphblas suitesparse-graphblas +``` diff --git a/build_graphblas_cffi.py b/build_graphblas_cffi.py new file mode 100644 index 0000000..94594e6 --- /dev/null +++ b/build_graphblas_cffi.py @@ -0,0 +1,98 @@ +import os +import sys +from pathlib import Path + +from cffi import FFI +from setuptools import Extension + +is_win = sys.platform.startswith("win") +ss_g = Path(__file__).parent / "suitesparse_graphblas" + +ffibuilder = FFI() + +# GraphBLAS_ROOT env var can point to the root directory of GraphBLAS to link against. +# Expected subdirectories: include/ (contains GraphBLAS.h), lib/, and bin/ (on Windows only) +# Otherwise fallback to default system folders. +graphblas_root = os.environ.get("GraphBLAS_ROOT") + +if not graphblas_root: + # Windows wheels.yml configures suitesparse.sh to install GraphBLAS to "C:\\GraphBLAS". + if is_win: + graphblas_root = "C:\\GraphBLAS" + elif Path("/usr/local/include/suitesparse").exists(): + # SuiteSparse:GraphBLAS 9.1+ built by suitesparse.sh + graphblas_root = "/usr/local" + else: + # Conda install + graphblas_root = sys.prefix + +include_dirs = [ + os.path.join(graphblas_root, "include"), + os.path.join(graphblas_root, "include", "suitesparse"), +] +library_dirs = [os.path.join(graphblas_root, "lib"), os.path.join(graphblas_root, "lib64")] +if is_win: + include_dirs.append(os.path.join(sys.prefix, "Library", "include")) + include_dirs.append(os.path.join(sys.prefix, "Library", "include", "suitesparse")) + library_dirs.append(os.path.join(sys.prefix, "Library", "lib")) + + include_dirs.append(os.path.join(graphblas_root, "include")) + include_dirs.append(os.path.join(graphblas_root, "include", "suitesparse")) + library_dirs.append(os.path.join(graphblas_root, "lib")) + library_dirs.append(os.path.join(graphblas_root, "bin")) + +ffibuilder.set_source( + "suitesparse_graphblas._graphblas", + (ss_g / "source.c").read_text(), + libraries=["graphblas"], + include_dirs=include_dirs, + library_dirs=library_dirs, +) + +ffibuilder.cdef((ss_g / "suitesparse_graphblas.h").read_text()) + + +def get_extension(apply_msvc_patch: bool = None, extra_compile_args=()): + """ + Get a setuptools.Extension version of this CFFI builder. + + In other words, enables `setup(ext_modules=[get_extension()])` + instead of `setup(cffi_modules=["build_graphblas_cffi.py:ffibuilder"])`. + + The main reason for this is to allow a patch for complex values when compiling on MSVC. + MSVC famously lacks support for standard C complex types like `double _Complex` and + `float _Complex`. Instead, MSVC has its own `_Dcomplex` and `_Fcomplex` types. + Cffi's machinery cannot be made to work with these types, so we instead + emit the regular standard C code and patch it manually. + + :param apply_msvc_patch: whether to apply the MSVC patch. + If None then auto-detect based on platform. + :param extra_compile_args: forwarded to Extension constructor. + """ + code_path = ss_g / "_graphblas.c" + ffibuilder.emit_c_code(str(code_path)) + + if apply_msvc_patch is None: + apply_msvc_patch = is_win + + if apply_msvc_patch: + msvc_code = code_path.read_text() + msvc_code = msvc_code.replace("float _Complex", "_Fcomplex") + msvc_code = msvc_code.replace("double _Complex", "_Dcomplex") + code_path.write_text(msvc_code) + + # Hack: tell GraphBLAS.h that we need MSVC-style complex values + extra_compile_args = list(extra_compile_args) + ["-DGxB_HAVE_COMPLEX_MSVC"] + + return Extension( + "suitesparse_graphblas._graphblas", + [os.path.join("suitesparse_graphblas", "_graphblas.c")], + libraries=["graphblas"], + include_dirs=include_dirs, + library_dirs=library_dirs, + extra_compile_args=extra_compile_args, + ) + + +if __name__ == "__main__": + ffibuilder.compile(verbose=True) diff --git a/continuous_integration/environment.yml b/continuous_integration/environment.yml new file mode 100644 index 0000000..00cf29e --- /dev/null +++ b/continuous_integration/environment.yml @@ -0,0 +1,13 @@ +name: suitesparse-graphblas +channels: + - conda-forge + - nodefaults # Only install packages from conda-forge for faster solving +dependencies: + # - graphblas=6.0.2 + - cffi + - cython + - numpy + - pytest + - pytest-randomly + - coverage + - pycparser diff --git a/docker_build.sh b/docker_build.sh new file mode 100755 index 0000000..77d3d80 --- /dev/null +++ b/docker_build.sh @@ -0,0 +1,50 @@ +#!/usr/bin/env bash +if [ $# -eq 0 ] + then + echo "Usage: ./docker_build.sh SUITESPARSE_BRANCH VERSION [BRANCH LOCATION PUSH] + +Example: ./docker_build.sh v5.1.3 5.1.3.1 main clone push + +If location is clone then a fresh git clone will be used. +If push is provided then the script will attempt to push to dockerhub." + exit 1 +fi + +IMAGE=graphblas/python-suitesparse-graphblas +SUITESPARSE=$1 +VERSION=$2 +BRANCH=$3 +LOCATION=$4 +PUSH=$5 + +COMPACT=${COMPACT:-0} + +if [ "$LOCATION" = "clone" ] +then + TMPDIR=$(mktemp -d) + if [ ! -e "$TMPDIR" ]; then + >&2 echo "Failed to create temp directory" + exit 1 + fi + trap "exit 1" HUP INT PIPE QUIT TERM + trap 'rm -rf "$TMPDIR"' EXIT + + cd "$TMPDIR" || exit + git clone --branch "$BRANCH" https://github.com/GraphBLAS/python-suitesparse-graphblas.git + cd python-suitesparse-graphblas || exit +fi + +docker build \ + --build-arg SUITESPARSE="${SUITESPARSE}" \ + --build-arg VERSION="${VERSION}" \ + --build-arg COMPACT="${COMPACT}" \ + -t "$IMAGE:$VERSION" \ + . + +docker tag "$IMAGE:$VERSION" "$IMAGE:latest" + +if [ "$PUSH" = "push" ] +then + docker push "$IMAGE:$VERSION" + docker push "$IMAGE:latest" +fi diff --git a/latest_suitesparse_graphblas_version.py b/latest_suitesparse_graphblas_version.py new file mode 100644 index 0000000..dbcc310 --- /dev/null +++ b/latest_suitesparse_graphblas_version.py @@ -0,0 +1,27 @@ +#!/usr/bin/env python + +""" +Find and print the latest version of SuiteSparse:GraphBLAS as published in this repo: +https://github.com/DrTimothyAldenDavis/GraphBLAS +""" + +import json +from urllib.error import URLError +from urllib.request import urlopen + +# fetch release data from GraphBLAS repo +for _ in range(5): + try: + with urlopen( + "https://api.github.com/repos/DrTimothyAldenDavis/GraphBLAS/releases/latest" + ) as url: + latest_release = json.load(url) + break + except URLError: + # sleep before trying again + from time import sleep + + sleep(1) + +version = latest_release["tag_name"].lstrip("v") +print(version) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..501d5f3 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,154 @@ +[build-system] +build-backend = "setuptools.build_meta" +requires = [ + "setuptools >=77", + "setuptools-git-versioning", + "wheel", + "cffi>=1.11", + # Free-threading in Python 3.14 requires Cython >=3.1 + "cython; python_version<'3.14'", + "cython>=3.1; python_version>='3.14'", + "numpy>=2.0", +] + +[project] +name = "suitesparse-graphblas" +dynamic = ["version"] +description = "SuiteSparse:GraphBLAS Python bindings." +readme = "README.md" +requires-python = ">=3.11" +license = "Apache-2.0" +license-files = ["LICENSE"] +authors = [ + {name = "Erik Welch", email = "erik.n.welch@gmail.com"}, + {name = "Jim Kitchen"}, + {name = "Michel Pelletier"}, + {name = "suitesparse-graphblas contributors"}, +] +maintainers = [ + {name = "Erik Welch", email = "erik.n.welch@gmail.com"}, + {name = "Jim Kitchen", email = "jim22k@gmail.com"}, + {name = "Michel Pelletier", email = "michel@graphegon.com"}, + {name = "Adam Lugowski", email = "alugowski@gmail.com"}, +] +keywords = [ + "graphblas", + "graph", + "sparse", + "matrix", + "lagraph", + "suitesparse", + "Networks", + "Graph Theory", + "Mathematics", + "network", + "discrete mathematics", + "math", +] +classifiers = [ + "Development Status :: 5 - Production/Stable", + "Environment :: WebAssembly :: Emscripten", + "Operating System :: MacOS :: MacOS X", + "Operating System :: POSIX :: Linux", + "Operating System :: Microsoft :: Windows", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3.14", + "Programming Language :: Python :: 3.15", + "Programming Language :: Python :: 3 :: Only", + "Programming Language :: Python :: Free Threading :: 2 - Beta", + "Intended Audience :: Developers", + "Intended Audience :: Other Audience", + "Intended Audience :: Science/Research", + "Topic :: Scientific/Engineering", + "Topic :: Scientific/Engineering :: Information Analysis", + "Topic :: Scientific/Engineering :: Mathematics", + "Topic :: Software Development :: Libraries :: Python Modules", +] +dependencies = [ + "cffi>=1.15", + "numpy>=1.24", +] +[project.urls] +homepage = "https://github.com/GraphBLAS/python-suitesparse-graphblas" +repository = "https://github.com/GraphBLAS/python-suitesparse-graphblas" +changelog = "https://github.com/GraphBLAS/python-suitesparse-graphblas/releases" + +[project.optional-dependencies] +test = [ + "pytest", +] +docs = [ + "pdoc", +] + +[tool.setuptools] +packages = [ + 'suitesparse_graphblas', + 'suitesparse_graphblas.api', + 'suitesparse_graphblas.api.examples', + 'suitesparse_graphblas.api.io', + 'suitesparse_graphblas.tests', + 'suitesparse_graphblas.io', +] + +# Build inputs that MANIFEST.in puts in the sdist. Nothing reads them at runtime, so keep them +# out of wheels (`utils.c` alone is about 1 MB, which matters most for Pyodide's downloads). +[tool.setuptools.exclude-package-data] +suitesparse_graphblas = ["*.c", "*.h"] + +[tool.setuptools-git-versioning] +enabled = true +dev_template = "{tag}+{ccount}.g{sha}" +dirty_template = "{tag}+{ccount}.g{sha}.dirty" + +[tool.black] +line-length = 100 +target-version = ["py311", "py312", "py313", "py314", "py315"] + +[tool.isort] +sections = ["FUTURE", "STDLIB", "THIRDPARTY", "FIRSTPARTY", "LOCALFOLDER"] +profile = "black" +skip_gitignore = true +float_to_top = true +default_section = "THIRDPARTY" +known_first_party = "suitesparse_graphblas" +line_length = 100 +skip_glob = ["*.pxd", "*.pyx"] + +[tool.coverage.run] +branch = true +source = ["suitesparse_graphblas"] +omit = [] +plugins = ["Cython.Coverage"] + +[tool.coverage.report] +ignore_errors = false +precision = 1 +fail_under = 0 +skip_covered = true +skip_empty = true +exclude_lines = [ + "pragma: no cover", + "raise AssertionError", + "raise NotImplementedError", +] + +[tool.pytest.ini_options] +testpaths = ["suitesparse_graphblas"] +addopts = [ + "--doctest-modules", + "--strict-config", # Error on unknown or misspelled config options + "--strict-markers", # Error on unregistered markers + "-ra", # Summarize all non-passing tests (skips, xfails, ...) at the end +] +xfail_strict = true +# Turn warnings into errors. On free-threaded builds this also catches +# "The global interpreter lock (GIL) has been enabled to load module ...". +filterwarnings = ["error"] +# NOTE: When running in Docker, use -w /tmp and --pyargs to avoid the source +# directory shadowing the installed package (compiled extensions aren't in the +# source tree). See AGENTS.md for the full Docker test commands. diff --git a/setup.py b/setup.py index 78ac159..c554dd9 100644 --- a/setup.py +++ b/setup.py @@ -1,14 +1,72 @@ -from setuptools import setup, find_packages +import os +import sys +from glob import glob + +import numpy as np +from setuptools import Extension, setup + +# Add current directory to the Python path because it's not present when running `pip install .` +sys.path.append(os.path.dirname(__file__)) +import build_graphblas_cffi # noqa: E402 # isort:skip + +try: + from Cython.Build import cythonize + from Cython.Compiler.Options import get_directive_defaults + + use_cython = True +except ImportError: + use_cython = False + +define_macros = [ + ("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION"), + # utils.pyx needs `PyArrayObject_fields.mem_handler`, added in NumPy 1.22. The NumPy + # version targeted by default depends on the NumPy being built against (1.19 for 2.0). + ("NPY_TARGET_VERSION", "NPY_1_22_API_VERSION"), +] + +# /d2FH4- flag needed only for early Python 3.8 builds on Windows. +# See https://cibuildwheel.readthedocs.io/en/stable/faq/ +# (Search for flag on page. Full link is long and causes the linter to fail the tests.) +# +# The /std:c11 flag is because the MSVC default is C89. +extra_compile_args = ["/d2FH4-", "/std:c11"] if sys.platform == "win32" else [] + +if use_cython: + suffix = ".pyx" + directive_defaults = get_directive_defaults() + directive_defaults["binding"] = True + directive_defaults["language_level"] = 3 + if os.environ.get("CYTHON_COVERAGE"): + directive_defaults["linetrace"] = True + define_macros.append(("CYTHON_TRACE_NOGIL", "1")) +else: + suffix = ".c" + # Make sure all required .c files are here + pyx_files = glob("suitesparse_graphblas/**.pyx", recursive=True) + c_files = glob("suitesparse_graphblas/**.c", recursive=True) + missing = {x[:-4] for x in pyx_files} - {x[:-2] for x in c_files} + if missing: + missing_c = sorted(x + ".c" for x in missing) + raise RuntimeError("Cython required when missing C files: " + ", ".join(missing_c)) + +include_dirs = [np.get_include(), os.path.join(sys.prefix, "include")] +ext_modules = [ + Extension( + name[: -len(suffix)].replace("/", ".").replace("\\", "."), + [name], + include_dirs=include_dirs, + define_macros=define_macros, + extra_compile_args=extra_compile_args, + ) + for name in glob(f"suitesparse_graphblas/**/*{suffix}", recursive=True) +] +if use_cython: + ext_modules = cythonize(ext_modules, include_path=include_dirs) + +if build_graphblas_cffi.is_win: + ext_modules.append(build_graphblas_cffi.get_extension(extra_compile_args=extra_compile_args)) setup( - name='suitesparse-graphblas', - version='4.0.3', - description='SuiteSparse:GraphBLAS Python bindings.', - packages=find_packages(), - author='Michel Pelletier, James Kitchen, Erik Welch', - cffi_modules=["suitesparse/graphblas/build.py:ffibuilder"], - install_requires=["cffi>=1.0.0"], - setup_requires=["cffi>=1.0.0", "pytest-runner"], - tests_require=["pytest"], + ext_modules=ext_modules, + cffi_modules=None if build_graphblas_cffi.is_win else ["build_graphblas_cffi.py:ffibuilder"], ) - diff --git a/suitesparse.sh b/suitesparse.sh new file mode 100755 index 0000000..d44b5c9 --- /dev/null +++ b/suitesparse.sh @@ -0,0 +1,202 @@ +#!/bin/bash + +set -x # echo on + +# parse SuiteSparse version from first argument, a git tag that ends in the version (no leading v) +if [[ $1 =~ refs/tags/v?([0-9]+\.[0-9]+\.[0-9]+-beta\.[0-9]+) ]]; then + # Naming used since v10.4.0-beta.1, e.g. "10.4.0-beta.2". Note that callers + # append the psg patch level (".0"), which is not part of the upstream tag. + echo "Beta version detected (X.Y.Z-beta.N)" + VERSION=${BASH_REMATCH[1]} +elif [[ $1 =~ refs/tags/([0-9]*\.[0-9]*\.[0-9]*\.beta[0-9]*).*$ ]]; then + # Older naming, e.g. "8.0.1.beta1" + echo "Beta version detected" + VERSION=${BASH_REMATCH[1]} +elif [[ $1 =~ refs/tags/([0-9]*\.[0-9]*\.[0-9]*)\..*$ ]]; then + VERSION=${BASH_REMATCH[1]} +else + echo "Specify a SuiteSparse version, such as: $0 refs/tags/7.4.3.0 (got: $1)" + exit 1 +fi +echo VERSION: "$VERSION" + +NPROC="$(nproc)" +if [ -z "${NPROC}" ]; then + # Default for platforms that don't have nproc. Mostly Windows. + NPROC="2" +fi + +cmake_params=() + +# Fail the build if OpenMP is missing instead of silently producing a serial +# library. GraphBLAS only warns and carries on, so a serial build stays +# invisible until someone measures it: conda-forge's graphblas 10.5.0 shipped +# that way on osx-arm64 while still depending on llvm-openmp. The matching +# runtime check on the built wheel is tests/test_package.py::test_openmp. +if [ -n "${SUITESPARSE_EMSCRIPTEN}" ]; then + # ...except for WebAssembly, which has no threads in Pyodide + cmake_params+=(-DSUITESPARSE_USE_OPENMP=OFF) +else + cmake_params+=(-DSUITESPARSE_USE_OPENMP=ON) +fi +cmake_params+=(-DSUITESPARSE_USE_STRICT=ON) +# STRICT makes any requested-but-missing feature fatal, and SuiteSparsePolicy +# defaults both of these to ON, so they must be turned off explicitly or the +# configure step dies on "CUDA required for SuiteSparse but not found". +cmake_params+=(-DSUITESPARSE_USE_CUDA=OFF) +cmake_params+=(-DSUITESPARSE_USE_FORTRAN=OFF) + +if [ -n "${BREW_LIBOMP}" ]; then + # macOS OpenMP flags. + # FindOpenMP doesn't find brew's libomp, so set the necessary configs manually. + cmake_params+=(-DOpenMP_C_FLAGS="-Xclang -fopenmp -I$(brew --prefix libomp)/include") + cmake_params+=(-DOpenMP_C_LIB_NAMES="libomp") + cmake_params+=(-DOpenMP_libomp_LIBRARY="omp") + LDFLAGS="-L$(brew --prefix libomp)/lib" + export LDFLAGS + + if [ -n "${SUITESPARSE_MACOS_ARCH}" ]; then + export CFLAGS="-arch ${SUITESPARSE_MACOS_ARCH}" + else + # build both x86 and ARM + export CFLAGS="-arch x86_64 -arch arm64" + fi +fi + +if [ -n "${CMAKE_GNUtoMS}" ]; then + # Windows needs .lib libraries, not .a + cmake_params+=(-DCMAKE_GNUtoMS=ON) + # Windows expects 'graphblas.lib', not 'libgraphblas.lib' + cmake_params+=(-DCMAKE_SHARED_LIBRARY_PREFIX=) + cmake_params+=(-DCMAKE_STATIC_LIBRARY_PREFIX=) +fi + +cmake_cmd=(cmake) +if [ -n "${SUITESPARSE_EMSCRIPTEN}" ]; then + # WebAssembly for Pyodide (emcc and pyodide must be on PATH, as in cibuildwheel's + # before-build). Build a static library to link into the extension module, with Pyodide's + # compiler flags (-fPIC and its exception handling ABI). Its -Oz is overridden by + # CMake's Release flags (-O3), or by EMCC_CFLAGS if that sets one (see wheels.yml). + cmake_cmd=(emcmake cmake) + CFLAGS="$(pyodide config get cflags)" || exit 1 + export CFLAGS + cmake_params+=(-DBUILD_SHARED_LIBS=OFF -DBUILD_STATIC_LIBS=ON) + # No CPU features to detect + cmake_params+=(-DGBNCPUFEAT=1) +fi + +if [ -n "${GRAPHBLAS_PREFIX}" ]; then + echo "GRAPHBLAS_PREFIX=${GRAPHBLAS_PREFIX}" + cmake_params+=(-DCMAKE_INSTALL_PREFIX="${GRAPHBLAS_PREFIX}") +fi + +# Start clean: this may run more than once (e.g., per Python version for Pyodide) +rm -rf "GraphBLAS-${VERSION}" +curl -L "https://github.com/DrTimothyAldenDavis/GraphBLAS/archive/refs/tags/v${VERSION}.tar.gz" | tar xzf - +cd "GraphBLAS-${VERSION}/build" || exit + +# Disable optimizing some rarely-used types for significantly faster builds and significantly smaller wheel size. +# Also the build with all types enabled sometimes stalls on GitHub Actions. Probably due to exceeded resource limits. +# These can still be used, they'll just have reduced performance (AFAIK similar to UDTs). +# GraphBLAS's own GB_control.h (as of 10.5.2) already disables INT8, INT16, UINT8 and UINT16, so +# the types left without FactoryKernels here are those four plus FC32, FC64 and UINT32. +# shellcheck disable=SC2129 +# echo "#define GxB_NO_BOOL 1" >> ../Source/GB_control.h # +# echo "#define GxB_NO_FP32 1" >> ../Source/GB_control.h # +# echo "#define GxB_NO_FP64 1" >> ../Source/GB_control.h # +echo "#define GxB_NO_FC32 1" >> ../Source/GB_control.h +echo "#define GxB_NO_FC64 1" >> ../Source/GB_control.h +# echo "#define GxB_NO_INT16 1" >> ../Source/GB_control.h # +# echo "#define GxB_NO_INT32 1" >> ../Source/GB_control.h # +# echo "#define GxB_NO_INT64 1" >> ../Source/GB_control.h # +# echo "#define GxB_NO_INT8 1" >> ../Source/GB_control.h # +echo "#define GxB_NO_UINT16 1" >> ../Source/GB_control.h +echo "#define GxB_NO_UINT32 1" >> ../Source/GB_control.h +# echo "#define GxB_NO_UINT64 1" >> ../Source/GB_control.h # +echo "#define GxB_NO_UINT8 1" >> ../Source/GB_control.h + +if [ -n "${SUITESPARSE_FAST_BUILD}" ]; then + echo "suitesparse.sh: Fast build requested." + # Disable optimizing even more types. This is for builds that don't finish in runner resource limits, + # such as emulated aarm64. + # shellcheck disable=SC2129 + +# echo "#define GxB_NO_BOOL 1" >> ../Source/GB_control.h +# echo "#define GxB_NO_FP32 1" >> ../Source/GB_control.h +# echo "#define GxB_NO_FP64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_FC32 1" >> ../Source/GB_control.h + echo "#define GxB_NO_FC64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT16 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT32 1" >> ../Source/GB_control.h +# echo "#define GxB_NO_INT64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT8 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT16 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT32 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT8 1" >> ../Source/GB_control.h +fi + +if [ -n "${SUITESPARSE_FASTEST_BUILD}" ]; then + echo "suitesparse.sh: Fastest build requested." + # Fastest build possible. For use in development and automated tests that do not depend on performance. + # shellcheck disable=SC2129 + + echo "#define GxB_NO_BOOL 1" >> ../Source/GB_control.h + echo "#define GxB_NO_FP32 1" >> ../Source/GB_control.h + echo "#define GxB_NO_FP64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_FC32 1" >> ../Source/GB_control.h + echo "#define GxB_NO_FC64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT16 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT32 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_INT8 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT16 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT32 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT64 1" >> ../Source/GB_control.h + echo "#define GxB_NO_UINT8 1" >> ../Source/GB_control.h + + # No FactoryKernels at all, which probably makes the GB_control.h settings above unnecessary + cmake_params+=(-DGRAPHBLAS_COMPACT=ON) +fi + +if [ -n "${CMAKE_GNUtoMS}" ]; then + # Windows options + echo "Skipping JIT on Windows for now because it fails to build." + cmake_params+=(-DGRAPHBLAS_USE_JIT=OFF) +else + # Use `GRAPHBLAS_JITINIT=2` so that the JIT functionality is available, but disabled by default. + # Level 2, "run", means that pre-JIT kernels may be used, which does not require a compiler at runtime. + cmake_params+=(-DGRAPHBLAS_JITINIT=2) + + # Disable JIT here too to not segfault in tests + cmake_params+=(-DGRAPHBLAS_USE_JIT=OFF) +fi + +# some platforms require sudo for installation, some don't have sudo at all +if [ "$(uname)" == "Darwin" ] && [ -z "${SUITESPARSE_EMSCRIPTEN}" ]; then + SUDO=sudo +else + SUDO="" +fi + +# Stop at the first failure. Carrying on would hide it until the wheel fails to link, or let +# the wheel link against a library left by an earlier run (e.g., for another Python). +"${cmake_cmd[@]}" .. -DCMAKE_BUILD_TYPE=Release -G 'Unix Makefiles' "${cmake_params[@]}" || exit 1 +make -j"$NPROC" || exit 1 +$SUDO make install || exit 1 + +if [ -n "${CMAKE_GNUtoMS}" ]; then + if [ -z "${GRAPHBLAS_PREFIX}" ]; then + # Windows default + GRAPHBLAS_PREFIX="C:/Program Files (x86)" + fi + + # Windows: + # CMAKE_STATIC_LIBRARY_PREFIX is sometimes ignored, possibly when the MinGW toolchain is selected. + # Drop the 'lib' prefix manually. + echo "manually removing lib prefix" + mv "${GRAPHBLAS_PREFIX}/lib/libgraphblas.lib" "${GRAPHBLAS_PREFIX}/lib/graphblas.lib" + mv "${GRAPHBLAS_PREFIX}/lib/libgraphblas.dll.a" "${GRAPHBLAS_PREFIX}/lib/graphblas.dll.a" + # cp instead of mv because the GNU tools expect libgraphblas.dll and the MS tools expect graphblas.dll. + cp "${GRAPHBLAS_PREFIX}/bin/libgraphblas.dll" "${GRAPHBLAS_PREFIX}/bin/graphblas.dll" +fi diff --git a/suitesparse/__init__.py b/suitesparse/__init__.py deleted file mode 100644 index 8b13789..0000000 --- a/suitesparse/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/suitesparse/graphblas/__init__.py b/suitesparse/graphblas/__init__.py deleted file mode 100644 index 8e13d9f..0000000 --- a/suitesparse/graphblas/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from ._graphblas import ffi, lib diff --git a/suitesparse/graphblas/build.py b/suitesparse/graphblas/build.py deleted file mode 100644 index 0a252e7..0000000 --- a/suitesparse/graphblas/build.py +++ /dev/null @@ -1,28 +0,0 @@ -import os -import sys -from cffi import FFI - -is_win = sys.platform.startswith("win") -thisdir = os.path.dirname(__file__) - -ffibuilder = FFI() - -with open(os.path.join(thisdir, "source.c")) as f: - source = f.read() - -ffibuilder.set_source( - "suitesparse.graphblas._graphblas", - source, - libraries=["graphblas"], - include_dirs=[os.path.join(sys.prefix, "include")], -) - -header = "suitesparse_graphblas.h" -if is_win: - header = "suitesparse_graphblas_no_complex.h" -gb_cdef = open(os.path.join(thisdir, header)) - -ffibuilder.cdef(gb_cdef.read()) - -if __name__ == "__main__": - ffibuilder.compile(verbose=True) diff --git a/suitesparse/graphblas/clean_header.py b/suitesparse/graphblas/clean_header.py deleted file mode 100644 index 3265a01..0000000 --- a/suitesparse/graphblas/clean_header.py +++ /dev/null @@ -1,97 +0,0 @@ -import sys -import os -import re - - -def rename_defined_constants(text): - # #define GB_PUBLIC extern - text = text.replace("GB_PUBLIC", "extern") - - return text - - -def remove_directives(text): - # There are a few cases of safe `#define` directives that we need to keep - # - #define FOO 12 - # - #define BAR ... - safe_define = re.compile(r"^#define\s+\w+\s+(\d+|\.{3})(\s|$)") - - out = [] - multiline = False - for line in text.splitlines(): - if not line: - out.append(line) - elif multiline: - if line[-1] != "\\": - multiline = False - out.append(f"/* {line} */") - elif line.lstrip()[0] == "#": - if line[-1] == "\\": - multiline = True - if not multiline and safe_define.match(line): - out.append(line) - else: - out.append(f"/* {line} */") - else: - out.append(line) - return "\n".join(out) - - -def remove_complex(text): - out = [] - extern_block = None - complex_extern = False - for line in text.splitlines(): - if extern_block is not None: - if "FC32" in line or "FC64" in line: - complex_extern = True - if line.replace(" ", "") == ");": # End of extern block - extern_block.append(line) - if complex_extern: - for i in range(len(extern_block)): - extern_block[i] = f"// {extern_block[i]}" - out.extend(extern_block) - extern_block = None - complex_extern = False - else: - extern_block.append(line) - elif not line: - out.append(line) - elif line.strip() == "extern": - extern_block = [line] - elif "FC32" in line or "FC64" in line: - # Check if the line is a terminating line - if re.search(r"FC(32|64)\s*;", line): - # By commenting the terminating line out, we lose the closing semicolon - # Walk up the lines, looking for the last non-commented out line - # then replace the trailing comma with a semicolon - for i in range(5): # it's never more than 5 away - if out[-i].startswith("//"): - continue - last_comma_pos = out[-i].rfind(",") - if last_comma_pos < 0: - continue - out[-i] = f"{out[-i][:last_comma_pos]};{out[-i][last_comma_pos+1:]}" - break - out.append(f"// {line}") - else: - out.append(line) - return "\n".join(out) - - -def main(filename): - with open(filename, "r") as f: - text = f.read() - text = rename_defined_constants(text) - text = remove_directives(text) - if "_no_complex_" in filename: - text = remove_complex(text) - with open(filename, "w") as f: - f.write(text) - - -if __name__ == "__main__": - filename = sys.argv[1] - if not os.path.exists(filename): - raise Exception(f'"{filename}" does not exist') - main(filename) diff --git a/suitesparse/graphblas/suitesparse_graphblas.h b/suitesparse/graphblas/suitesparse_graphblas.h deleted file mode 100644 index e047fbb..0000000 --- a/suitesparse/graphblas/suitesparse_graphblas.h +++ /dev/null @@ -1,3058 +0,0 @@ -/* This file is automatically generated */ -/* GrB typedefs */ -typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; -typedef struct GB_Descriptor_opaque *GrB_Descriptor; -typedef struct GB_Matrix_opaque *GrB_Matrix; -typedef struct GB_Monoid_opaque *GrB_Monoid; -typedef struct GB_Semiring_opaque *GrB_Semiring; -typedef struct GB_Type_opaque *GrB_Type; -typedef struct GB_UnaryOp_opaque *GrB_UnaryOp; -typedef struct GB_Vector_opaque *GrB_Vector; -typedef uint64_t GrB_Index; - -/* GxB typedefs */ -typedef double _Complex GxB_FC64_t; -typedef float _Complex GxB_FC32_t; -typedef struct GB_Scalar_opaque *GxB_Scalar; -typedef struct GB_SelectOp_opaque *GxB_SelectOp; - -/* GxB typedefs (functions) */ -typedef bool (*GxB_select_function)(GrB_Index i, GrB_Index j, const void *x, const void *thunk); -typedef void (*GxB_binary_function)(void *, const void *, const void *); -typedef void (*GxB_unary_function)(void *, const void *); - -/* GrB enums */ -typedef enum -{ - GrB_OUTP = 0, - GrB_MASK = 1, - GrB_INP0 = 2, - GrB_INP1 = 3, - GxB_DESCRIPTOR_NTHREADS = 5, - GxB_DESCRIPTOR_CHUNK = 7, - GxB_DESCRIPTOR_GPU_CONTROL = 21, - GxB_DESCRIPTOR_GPU_CHUNK = 22, - GxB_AxB_METHOD = 1000, - GxB_SORT = 35 -} GrB_Desc_Field; - -typedef enum -{ - GxB_DEFAULT = 0, - GrB_REPLACE = 1, - GrB_COMP = 2, - GrB_STRUCTURE = 4, - GrB_TRAN = 3, - GxB_GPU_ALWAYS = 2001, - GxB_GPU_NEVER = 2002, - GxB_AxB_GUSTAVSON = 1001, - GxB_AxB_DOT = 1003, - GxB_AxB_HASH = 1004, - GxB_AxB_SAXPY = 1005 -} GrB_Desc_Value; - -typedef enum -{ - GrB_SUCCESS = 0, - GrB_NO_VALUE = 1, - GrB_UNINITIALIZED_OBJECT = 2, - GrB_INVALID_OBJECT = 3, - GrB_NULL_POINTER = 4, - GrB_INVALID_VALUE = 5, - GrB_INVALID_INDEX = 6, - GrB_DOMAIN_MISMATCH = 7, - GrB_DIMENSION_MISMATCH = 8, - GrB_OUTPUT_NOT_EMPTY = 9, - GrB_OUT_OF_MEMORY = 10, - GrB_INSUFFICIENT_SPACE = 11, - GrB_INDEX_OUT_OF_BOUNDS = 12, - GrB_PANIC = 13 -} GrB_Info; - -typedef enum -{ - GrB_NONBLOCKING = 0, - GrB_BLOCKING = 1 -} GrB_Mode; - -/* GxB enums */ -typedef enum -{ - GxB_BY_ROW = 0, - GxB_BY_COL = 1, - GxB_NO_FORMAT = -1 -} GxB_Format_Value; - -typedef enum -{ - GxB_HYPER_SWITCH = 0, - GxB_BITMAP_SWITCH = 34, - GxB_FORMAT = 1, - GxB_MODE = 2, - GxB_LIBRARY_NAME = 8, - GxB_LIBRARY_VERSION = 9, - GxB_LIBRARY_DATE = 10, - GxB_LIBRARY_ABOUT = 11, - GxB_LIBRARY_URL = 12, - GxB_LIBRARY_LICENSE = 13, - GxB_LIBRARY_COMPILE_DATE = 14, - GxB_LIBRARY_COMPILE_TIME = 15, - GxB_API_VERSION = 16, - GxB_API_DATE = 17, - GxB_API_ABOUT = 18, - GxB_API_URL = 19, - GxB_GLOBAL_NTHREADS = 5, - GxB_GLOBAL_CHUNK = 7, - GxB_BURBLE = 99, - GxB_SPARSITY_STATUS = 33, - GxB_SPARSITY_CONTROL = 32, - GxB_GLOBAL_GPU_CONTROL = 21, - GxB_GLOBAL_GPU_CHUNK = 22 -} GxB_Option_Field; - -typedef enum -{ - GxB_SILENT = 0, - GxB_SUMMARY = 1, - GxB_SHORT = 2, - GxB_COMPLETE = 3, - GxB_SHORT_VERBOSE = 4, - GxB_COMPLETE_VERBOSE = 5 -} GxB_Print_Level; - -/* GrB consts */ -extern const uint64_t *GrB_ALL; - -/* GxB consts */ -extern const GxB_Format_Value GxB_FORMAT_DEFAULT; -extern const double GxB_ALWAYS_HYPER; -extern const double GxB_HYPER_DEFAULT; -extern const double GxB_NEVER_HYPER; - -/* GrB objects */ -extern GrB_BinaryOp GrB_BAND_INT8; -extern GrB_BinaryOp GrB_BAND_INT16; -extern GrB_BinaryOp GrB_BAND_INT32; -extern GrB_BinaryOp GrB_BAND_INT64; -extern GrB_BinaryOp GrB_BAND_UINT8; -extern GrB_BinaryOp GrB_BAND_UINT16; -extern GrB_BinaryOp GrB_BAND_UINT32; -extern GrB_BinaryOp GrB_BAND_UINT64; -extern GrB_BinaryOp GrB_BOR_INT8; -extern GrB_BinaryOp GrB_BOR_INT16; -extern GrB_BinaryOp GrB_BOR_INT32; -extern GrB_BinaryOp GrB_BOR_INT64; -extern GrB_BinaryOp GrB_BOR_UINT8; -extern GrB_BinaryOp GrB_BOR_UINT16; -extern GrB_BinaryOp GrB_BOR_UINT32; -extern GrB_BinaryOp GrB_BOR_UINT64; -extern GrB_BinaryOp GrB_BXNOR_INT8; -extern GrB_BinaryOp GrB_BXNOR_INT16; -extern GrB_BinaryOp GrB_BXNOR_INT32; -extern GrB_BinaryOp GrB_BXNOR_INT64; -extern GrB_BinaryOp GrB_BXNOR_UINT8; -extern GrB_BinaryOp GrB_BXNOR_UINT16; -extern GrB_BinaryOp GrB_BXNOR_UINT32; -extern GrB_BinaryOp GrB_BXNOR_UINT64; -extern GrB_BinaryOp GrB_BXOR_INT8; -extern GrB_BinaryOp GrB_BXOR_INT16; -extern GrB_BinaryOp GrB_BXOR_INT32; -extern GrB_BinaryOp GrB_BXOR_INT64; -extern GrB_BinaryOp GrB_BXOR_UINT8; -extern GrB_BinaryOp GrB_BXOR_UINT16; -extern GrB_BinaryOp GrB_BXOR_UINT32; -extern GrB_BinaryOp GrB_BXOR_UINT64; -extern GrB_BinaryOp GrB_DIV_BOOL; -extern GrB_BinaryOp GrB_DIV_FP32; -extern GrB_BinaryOp GrB_DIV_FP64; -extern GrB_BinaryOp GrB_DIV_INT8; -extern GrB_BinaryOp GrB_DIV_INT16; -extern GrB_BinaryOp GrB_DIV_INT32; -extern GrB_BinaryOp GrB_DIV_INT64; -extern GrB_BinaryOp GrB_DIV_UINT8; -extern GrB_BinaryOp GrB_DIV_UINT16; -extern GrB_BinaryOp GrB_DIV_UINT32; -extern GrB_BinaryOp GrB_DIV_UINT64; -extern GrB_BinaryOp GrB_EQ_BOOL; -extern GrB_BinaryOp GrB_EQ_FP32; -extern GrB_BinaryOp GrB_EQ_FP64; -extern GrB_BinaryOp GrB_EQ_INT8; -extern GrB_BinaryOp GrB_EQ_INT16; -extern GrB_BinaryOp GrB_EQ_INT32; -extern GrB_BinaryOp GrB_EQ_INT64; -extern GrB_BinaryOp GrB_EQ_UINT8; -extern GrB_BinaryOp GrB_EQ_UINT16; -extern GrB_BinaryOp GrB_EQ_UINT32; -extern GrB_BinaryOp GrB_EQ_UINT64; -extern GrB_BinaryOp GrB_FIRST_BOOL; -extern GrB_BinaryOp GrB_FIRST_FP32; -extern GrB_BinaryOp GrB_FIRST_FP64; -extern GrB_BinaryOp GrB_FIRST_INT8; -extern GrB_BinaryOp GrB_FIRST_INT16; -extern GrB_BinaryOp GrB_FIRST_INT32; -extern GrB_BinaryOp GrB_FIRST_INT64; -extern GrB_BinaryOp GrB_FIRST_UINT8; -extern GrB_BinaryOp GrB_FIRST_UINT16; -extern GrB_BinaryOp GrB_FIRST_UINT32; -extern GrB_BinaryOp GrB_FIRST_UINT64; -extern GrB_BinaryOp GrB_GE_BOOL; -extern GrB_BinaryOp GrB_GE_FP32; -extern GrB_BinaryOp GrB_GE_FP64; -extern GrB_BinaryOp GrB_GE_INT8; -extern GrB_BinaryOp GrB_GE_INT16; -extern GrB_BinaryOp GrB_GE_INT32; -extern GrB_BinaryOp GrB_GE_INT64; -extern GrB_BinaryOp GrB_GE_UINT8; -extern GrB_BinaryOp GrB_GE_UINT16; -extern GrB_BinaryOp GrB_GE_UINT32; -extern GrB_BinaryOp GrB_GE_UINT64; -extern GrB_BinaryOp GrB_GT_BOOL; -extern GrB_BinaryOp GrB_GT_FP32; -extern GrB_BinaryOp GrB_GT_FP64; -extern GrB_BinaryOp GrB_GT_INT8; -extern GrB_BinaryOp GrB_GT_INT16; -extern GrB_BinaryOp GrB_GT_INT32; -extern GrB_BinaryOp GrB_GT_INT64; -extern GrB_BinaryOp GrB_GT_UINT8; -extern GrB_BinaryOp GrB_GT_UINT16; -extern GrB_BinaryOp GrB_GT_UINT32; -extern GrB_BinaryOp GrB_GT_UINT64; -extern GrB_BinaryOp GrB_LAND; -extern GrB_BinaryOp GrB_LE_BOOL; -extern GrB_BinaryOp GrB_LE_FP32; -extern GrB_BinaryOp GrB_LE_FP64; -extern GrB_BinaryOp GrB_LE_INT8; -extern GrB_BinaryOp GrB_LE_INT16; -extern GrB_BinaryOp GrB_LE_INT32; -extern GrB_BinaryOp GrB_LE_INT64; -extern GrB_BinaryOp GrB_LE_UINT8; -extern GrB_BinaryOp GrB_LE_UINT16; -extern GrB_BinaryOp GrB_LE_UINT32; -extern GrB_BinaryOp GrB_LE_UINT64; -extern GrB_BinaryOp GrB_LOR; -extern GrB_BinaryOp GrB_LT_BOOL; -extern GrB_BinaryOp GrB_LT_FP32; -extern GrB_BinaryOp GrB_LT_FP64; -extern GrB_BinaryOp GrB_LT_INT8; -extern GrB_BinaryOp GrB_LT_INT16; -extern GrB_BinaryOp GrB_LT_INT32; -extern GrB_BinaryOp GrB_LT_INT64; -extern GrB_BinaryOp GrB_LT_UINT8; -extern GrB_BinaryOp GrB_LT_UINT16; -extern GrB_BinaryOp GrB_LT_UINT32; -extern GrB_BinaryOp GrB_LT_UINT64; -extern GrB_BinaryOp GrB_LXNOR; -extern GrB_BinaryOp GrB_LXOR; -extern GrB_BinaryOp GrB_MAX_BOOL; -extern GrB_BinaryOp GrB_MAX_FP32; -extern GrB_BinaryOp GrB_MAX_FP64; -extern GrB_BinaryOp GrB_MAX_INT8; -extern GrB_BinaryOp GrB_MAX_INT16; -extern GrB_BinaryOp GrB_MAX_INT32; -extern GrB_BinaryOp GrB_MAX_INT64; -extern GrB_BinaryOp GrB_MAX_UINT8; -extern GrB_BinaryOp GrB_MAX_UINT16; -extern GrB_BinaryOp GrB_MAX_UINT32; -extern GrB_BinaryOp GrB_MAX_UINT64; -extern GrB_BinaryOp GrB_MINUS_BOOL; -extern GrB_BinaryOp GrB_MINUS_FP32; -extern GrB_BinaryOp GrB_MINUS_FP64; -extern GrB_BinaryOp GrB_MINUS_INT8; -extern GrB_BinaryOp GrB_MINUS_INT16; -extern GrB_BinaryOp GrB_MINUS_INT32; -extern GrB_BinaryOp GrB_MINUS_INT64; -extern GrB_BinaryOp GrB_MINUS_UINT8; -extern GrB_BinaryOp GrB_MINUS_UINT16; -extern GrB_BinaryOp GrB_MINUS_UINT32; -extern GrB_BinaryOp GrB_MINUS_UINT64; -extern GrB_BinaryOp GrB_MIN_BOOL; -extern GrB_BinaryOp GrB_MIN_FP32; -extern GrB_BinaryOp GrB_MIN_FP64; -extern GrB_BinaryOp GrB_MIN_INT8; -extern GrB_BinaryOp GrB_MIN_INT16; -extern GrB_BinaryOp GrB_MIN_INT32; -extern GrB_BinaryOp GrB_MIN_INT64; -extern GrB_BinaryOp GrB_MIN_UINT8; -extern GrB_BinaryOp GrB_MIN_UINT16; -extern GrB_BinaryOp GrB_MIN_UINT32; -extern GrB_BinaryOp GrB_MIN_UINT64; -extern GrB_BinaryOp GrB_NE_BOOL; -extern GrB_BinaryOp GrB_NE_FP32; -extern GrB_BinaryOp GrB_NE_FP64; -extern GrB_BinaryOp GrB_NE_INT8; -extern GrB_BinaryOp GrB_NE_INT16; -extern GrB_BinaryOp GrB_NE_INT32; -extern GrB_BinaryOp GrB_NE_INT64; -extern GrB_BinaryOp GrB_NE_UINT8; -extern GrB_BinaryOp GrB_NE_UINT16; -extern GrB_BinaryOp GrB_NE_UINT32; -extern GrB_BinaryOp GrB_NE_UINT64; -extern GrB_BinaryOp GrB_PLUS_BOOL; -extern GrB_BinaryOp GrB_PLUS_FP32; -extern GrB_BinaryOp GrB_PLUS_FP64; -extern GrB_BinaryOp GrB_PLUS_INT8; -extern GrB_BinaryOp GrB_PLUS_INT16; -extern GrB_BinaryOp GrB_PLUS_INT32; -extern GrB_BinaryOp GrB_PLUS_INT64; -extern GrB_BinaryOp GrB_PLUS_UINT8; -extern GrB_BinaryOp GrB_PLUS_UINT16; -extern GrB_BinaryOp GrB_PLUS_UINT32; -extern GrB_BinaryOp GrB_PLUS_UINT64; -extern GrB_BinaryOp GrB_SECOND_BOOL; -extern GrB_BinaryOp GrB_SECOND_FP32; -extern GrB_BinaryOp GrB_SECOND_FP64; -extern GrB_BinaryOp GrB_SECOND_INT8; -extern GrB_BinaryOp GrB_SECOND_INT16; -extern GrB_BinaryOp GrB_SECOND_INT32; -extern GrB_BinaryOp GrB_SECOND_INT64; -extern GrB_BinaryOp GrB_SECOND_UINT8; -extern GrB_BinaryOp GrB_SECOND_UINT16; -extern GrB_BinaryOp GrB_SECOND_UINT32; -extern GrB_BinaryOp GrB_SECOND_UINT64; -extern GrB_BinaryOp GrB_TIMES_BOOL; -extern GrB_BinaryOp GrB_TIMES_FP32; -extern GrB_BinaryOp GrB_TIMES_FP64; -extern GrB_BinaryOp GrB_TIMES_INT8; -extern GrB_BinaryOp GrB_TIMES_INT16; -extern GrB_BinaryOp GrB_TIMES_INT32; -extern GrB_BinaryOp GrB_TIMES_INT64; -extern GrB_BinaryOp GrB_TIMES_UINT8; -extern GrB_BinaryOp GrB_TIMES_UINT16; -extern GrB_BinaryOp GrB_TIMES_UINT32; -extern GrB_BinaryOp GrB_TIMES_UINT64; -extern GrB_Descriptor GrB_DESC_C; -extern GrB_Descriptor GrB_DESC_CT0; -extern GrB_Descriptor GrB_DESC_CT0T1; -extern GrB_Descriptor GrB_DESC_CT1; -extern GrB_Descriptor GrB_DESC_R; -extern GrB_Descriptor GrB_DESC_RC; -extern GrB_Descriptor GrB_DESC_RCT0; -extern GrB_Descriptor GrB_DESC_RCT0T1; -extern GrB_Descriptor GrB_DESC_RCT1; -extern GrB_Descriptor GrB_DESC_RS; -extern GrB_Descriptor GrB_DESC_RSC; -extern GrB_Descriptor GrB_DESC_RSCT0; -extern GrB_Descriptor GrB_DESC_RSCT0T1; -extern GrB_Descriptor GrB_DESC_RSCT1; -extern GrB_Descriptor GrB_DESC_RST0; -extern GrB_Descriptor GrB_DESC_RST0T1; -extern GrB_Descriptor GrB_DESC_RST1; -extern GrB_Descriptor GrB_DESC_RT0; -extern GrB_Descriptor GrB_DESC_RT0T1; -extern GrB_Descriptor GrB_DESC_RT1; -extern GrB_Descriptor GrB_DESC_S; -extern GrB_Descriptor GrB_DESC_SC; -extern GrB_Descriptor GrB_DESC_SCT0; -extern GrB_Descriptor GrB_DESC_SCT0T1; -extern GrB_Descriptor GrB_DESC_SCT1; -extern GrB_Descriptor GrB_DESC_ST0; -extern GrB_Descriptor GrB_DESC_ST0T1; -extern GrB_Descriptor GrB_DESC_ST1; -extern GrB_Descriptor GrB_DESC_T0; -extern GrB_Descriptor GrB_DESC_T0T1; -extern GrB_Descriptor GrB_DESC_T1; -extern GrB_Monoid GrB_LAND_MONOID_BOOL; -extern GrB_Monoid GrB_LOR_MONOID_BOOL; -extern GrB_Monoid GrB_LXNOR_MONOID_BOOL; -extern GrB_Monoid GrB_LXOR_MONOID_BOOL; -extern GrB_Monoid GrB_MAX_MONOID_FP32; -extern GrB_Monoid GrB_MAX_MONOID_FP64; -extern GrB_Monoid GrB_MAX_MONOID_INT8; -extern GrB_Monoid GrB_MAX_MONOID_INT16; -extern GrB_Monoid GrB_MAX_MONOID_INT32; -extern GrB_Monoid GrB_MAX_MONOID_INT64; -extern GrB_Monoid GrB_MAX_MONOID_UINT8; -extern GrB_Monoid GrB_MAX_MONOID_UINT16; -extern GrB_Monoid GrB_MAX_MONOID_UINT32; -extern GrB_Monoid GrB_MAX_MONOID_UINT64; -extern GrB_Monoid GrB_MIN_MONOID_FP32; -extern GrB_Monoid GrB_MIN_MONOID_FP64; -extern GrB_Monoid GrB_MIN_MONOID_INT8; -extern GrB_Monoid GrB_MIN_MONOID_INT16; -extern GrB_Monoid GrB_MIN_MONOID_INT32; -extern GrB_Monoid GrB_MIN_MONOID_INT64; -extern GrB_Monoid GrB_MIN_MONOID_UINT8; -extern GrB_Monoid GrB_MIN_MONOID_UINT16; -extern GrB_Monoid GrB_MIN_MONOID_UINT32; -extern GrB_Monoid GrB_MIN_MONOID_UINT64; -extern GrB_Monoid GrB_PLUS_MONOID_FP32; -extern GrB_Monoid GrB_PLUS_MONOID_FP64; -extern GrB_Monoid GrB_PLUS_MONOID_INT8; -extern GrB_Monoid GrB_PLUS_MONOID_INT16; -extern GrB_Monoid GrB_PLUS_MONOID_INT32; -extern GrB_Monoid GrB_PLUS_MONOID_INT64; -extern GrB_Monoid GrB_PLUS_MONOID_UINT8; -extern GrB_Monoid GrB_PLUS_MONOID_UINT16; -extern GrB_Monoid GrB_PLUS_MONOID_UINT32; -extern GrB_Monoid GrB_PLUS_MONOID_UINT64; -extern GrB_Monoid GrB_TIMES_MONOID_FP32; -extern GrB_Monoid GrB_TIMES_MONOID_FP64; -extern GrB_Monoid GrB_TIMES_MONOID_INT8; -extern GrB_Monoid GrB_TIMES_MONOID_INT16; -extern GrB_Monoid GrB_TIMES_MONOID_INT32; -extern GrB_Monoid GrB_TIMES_MONOID_INT64; -extern GrB_Monoid GrB_TIMES_MONOID_UINT8; -extern GrB_Monoid GrB_TIMES_MONOID_UINT16; -extern GrB_Monoid GrB_TIMES_MONOID_UINT32; -extern GrB_Monoid GrB_TIMES_MONOID_UINT64; -extern GrB_Semiring GrB_LAND_LOR_SEMIRING_BOOL; -extern GrB_Semiring GrB_LOR_LAND_SEMIRING_BOOL; -extern GrB_Semiring GrB_LXNOR_LOR_SEMIRING_BOOL; -extern GrB_Semiring GrB_LXOR_LAND_SEMIRING_BOOL; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT64; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP32; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP64; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT8; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT16; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT32; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT64; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT8; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT16; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT32; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT64; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP32; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP64; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT8; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT16; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT32; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT64; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT8; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT16; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT32; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT64; -extern GrB_Type GrB_BOOL; -extern GrB_Type GrB_FP32; -extern GrB_Type GrB_FP64; -extern GrB_Type GrB_INT8; -extern GrB_Type GrB_INT16; -extern GrB_Type GrB_INT32; -extern GrB_Type GrB_INT64; -extern GrB_Type GrB_UINT8; -extern GrB_Type GrB_UINT16; -extern GrB_Type GrB_UINT32; -extern GrB_Type GrB_UINT64; -extern GrB_UnaryOp GrB_ABS_BOOL; -extern GrB_UnaryOp GrB_ABS_FP32; -extern GrB_UnaryOp GrB_ABS_FP64; -extern GrB_UnaryOp GrB_ABS_INT8; -extern GrB_UnaryOp GrB_ABS_INT16; -extern GrB_UnaryOp GrB_ABS_INT32; -extern GrB_UnaryOp GrB_ABS_INT64; -extern GrB_UnaryOp GrB_ABS_UINT8; -extern GrB_UnaryOp GrB_ABS_UINT16; -extern GrB_UnaryOp GrB_ABS_UINT32; -extern GrB_UnaryOp GrB_ABS_UINT64; -extern GrB_UnaryOp GrB_AINV_BOOL; -extern GrB_UnaryOp GrB_AINV_FP32; -extern GrB_UnaryOp GrB_AINV_FP64; -extern GrB_UnaryOp GrB_AINV_INT8; -extern GrB_UnaryOp GrB_AINV_INT16; -extern GrB_UnaryOp GrB_AINV_INT32; -extern GrB_UnaryOp GrB_AINV_INT64; -extern GrB_UnaryOp GrB_AINV_UINT8; -extern GrB_UnaryOp GrB_AINV_UINT16; -extern GrB_UnaryOp GrB_AINV_UINT32; -extern GrB_UnaryOp GrB_AINV_UINT64; -extern GrB_UnaryOp GrB_BNOT_INT8; -extern GrB_UnaryOp GrB_BNOT_INT16; -extern GrB_UnaryOp GrB_BNOT_INT32; -extern GrB_UnaryOp GrB_BNOT_INT64; -extern GrB_UnaryOp GrB_BNOT_UINT8; -extern GrB_UnaryOp GrB_BNOT_UINT16; -extern GrB_UnaryOp GrB_BNOT_UINT32; -extern GrB_UnaryOp GrB_BNOT_UINT64; -extern GrB_UnaryOp GrB_IDENTITY_BOOL; -extern GrB_UnaryOp GrB_IDENTITY_FP32; -extern GrB_UnaryOp GrB_IDENTITY_FP64; -extern GrB_UnaryOp GrB_IDENTITY_INT8; -extern GrB_UnaryOp GrB_IDENTITY_INT16; -extern GrB_UnaryOp GrB_IDENTITY_INT32; -extern GrB_UnaryOp GrB_IDENTITY_INT64; -extern GrB_UnaryOp GrB_IDENTITY_UINT8; -extern GrB_UnaryOp GrB_IDENTITY_UINT16; -extern GrB_UnaryOp GrB_IDENTITY_UINT32; -extern GrB_UnaryOp GrB_IDENTITY_UINT64; -extern GrB_UnaryOp GrB_LNOT; -extern GrB_UnaryOp GrB_MINV_BOOL; -extern GrB_UnaryOp GrB_MINV_FP32; -extern GrB_UnaryOp GrB_MINV_FP64; -extern GrB_UnaryOp GrB_MINV_INT8; -extern GrB_UnaryOp GrB_MINV_INT16; -extern GrB_UnaryOp GrB_MINV_INT32; -extern GrB_UnaryOp GrB_MINV_INT64; -extern GrB_UnaryOp GrB_MINV_UINT8; -extern GrB_UnaryOp GrB_MINV_UINT16; -extern GrB_UnaryOp GrB_MINV_UINT32; -extern GrB_UnaryOp GrB_MINV_UINT64; - -/* GrB objects (extended) */ -extern GrB_BinaryOp GxB_ANY_BOOL; -extern GrB_BinaryOp GxB_ANY_FC32; -extern GrB_BinaryOp GxB_ANY_FC64; -extern GrB_BinaryOp GxB_ANY_FP32; -extern GrB_BinaryOp GxB_ANY_FP64; -extern GrB_BinaryOp GxB_ANY_INT8; -extern GrB_BinaryOp GxB_ANY_INT16; -extern GrB_BinaryOp GxB_ANY_INT32; -extern GrB_BinaryOp GxB_ANY_INT64; -extern GrB_BinaryOp GxB_ANY_UINT8; -extern GrB_BinaryOp GxB_ANY_UINT16; -extern GrB_BinaryOp GxB_ANY_UINT32; -extern GrB_BinaryOp GxB_ANY_UINT64; -extern GrB_BinaryOp GxB_ATAN2_FP32; -extern GrB_BinaryOp GxB_ATAN2_FP64; -extern GrB_BinaryOp GxB_BCLR_INT8; -extern GrB_BinaryOp GxB_BCLR_INT16; -extern GrB_BinaryOp GxB_BCLR_INT32; -extern GrB_BinaryOp GxB_BCLR_INT64; -extern GrB_BinaryOp GxB_BCLR_UINT8; -extern GrB_BinaryOp GxB_BCLR_UINT16; -extern GrB_BinaryOp GxB_BCLR_UINT32; -extern GrB_BinaryOp GxB_BCLR_UINT64; -extern GrB_BinaryOp GxB_BGET_INT8; -extern GrB_BinaryOp GxB_BGET_INT16; -extern GrB_BinaryOp GxB_BGET_INT32; -extern GrB_BinaryOp GxB_BGET_INT64; -extern GrB_BinaryOp GxB_BGET_UINT8; -extern GrB_BinaryOp GxB_BGET_UINT16; -extern GrB_BinaryOp GxB_BGET_UINT32; -extern GrB_BinaryOp GxB_BGET_UINT64; -extern GrB_BinaryOp GxB_BSET_INT8; -extern GrB_BinaryOp GxB_BSET_INT16; -extern GrB_BinaryOp GxB_BSET_INT32; -extern GrB_BinaryOp GxB_BSET_INT64; -extern GrB_BinaryOp GxB_BSET_UINT8; -extern GrB_BinaryOp GxB_BSET_UINT16; -extern GrB_BinaryOp GxB_BSET_UINT32; -extern GrB_BinaryOp GxB_BSET_UINT64; -extern GrB_BinaryOp GxB_BSHIFT_INT8; -extern GrB_BinaryOp GxB_BSHIFT_INT16; -extern GrB_BinaryOp GxB_BSHIFT_INT32; -extern GrB_BinaryOp GxB_BSHIFT_INT64; -extern GrB_BinaryOp GxB_BSHIFT_UINT8; -extern GrB_BinaryOp GxB_BSHIFT_UINT16; -extern GrB_BinaryOp GxB_BSHIFT_UINT32; -extern GrB_BinaryOp GxB_BSHIFT_UINT64; -extern GrB_BinaryOp GxB_CMPLX_FP32; -extern GrB_BinaryOp GxB_CMPLX_FP64; -extern GrB_BinaryOp GxB_COPYSIGN_FP32; -extern GrB_BinaryOp GxB_COPYSIGN_FP64; -extern GrB_BinaryOp GxB_DIV_FC32; -extern GrB_BinaryOp GxB_DIV_FC64; -extern GrB_BinaryOp GxB_EQ_FC32; -extern GrB_BinaryOp GxB_EQ_FC64; -extern GrB_BinaryOp GxB_FIRSTI1_INT32; -extern GrB_BinaryOp GxB_FIRSTI1_INT64; -extern GrB_BinaryOp GxB_FIRSTI_INT32; -extern GrB_BinaryOp GxB_FIRSTI_INT64; -extern GrB_BinaryOp GxB_FIRSTJ1_INT32; -extern GrB_BinaryOp GxB_FIRSTJ1_INT64; -extern GrB_BinaryOp GxB_FIRSTJ_INT32; -extern GrB_BinaryOp GxB_FIRSTJ_INT64; -extern GrB_BinaryOp GxB_FIRST_FC32; -extern GrB_BinaryOp GxB_FIRST_FC64; -extern GrB_BinaryOp GxB_FMOD_FP32; -extern GrB_BinaryOp GxB_FMOD_FP64; -extern GrB_BinaryOp GxB_HYPOT_FP32; -extern GrB_BinaryOp GxB_HYPOT_FP64; -extern GrB_BinaryOp GxB_ISEQ_BOOL; -extern GrB_BinaryOp GxB_ISEQ_FC32; -extern GrB_BinaryOp GxB_ISEQ_FC64; -extern GrB_BinaryOp GxB_ISEQ_FP32; -extern GrB_BinaryOp GxB_ISEQ_FP64; -extern GrB_BinaryOp GxB_ISEQ_INT8; -extern GrB_BinaryOp GxB_ISEQ_INT16; -extern GrB_BinaryOp GxB_ISEQ_INT32; -extern GrB_BinaryOp GxB_ISEQ_INT64; -extern GrB_BinaryOp GxB_ISEQ_UINT8; -extern GrB_BinaryOp GxB_ISEQ_UINT16; -extern GrB_BinaryOp GxB_ISEQ_UINT32; -extern GrB_BinaryOp GxB_ISEQ_UINT64; -extern GrB_BinaryOp GxB_ISGE_BOOL; -extern GrB_BinaryOp GxB_ISGE_FP32; -extern GrB_BinaryOp GxB_ISGE_FP64; -extern GrB_BinaryOp GxB_ISGE_INT8; -extern GrB_BinaryOp GxB_ISGE_INT16; -extern GrB_BinaryOp GxB_ISGE_INT32; -extern GrB_BinaryOp GxB_ISGE_INT64; -extern GrB_BinaryOp GxB_ISGE_UINT8; -extern GrB_BinaryOp GxB_ISGE_UINT16; -extern GrB_BinaryOp GxB_ISGE_UINT32; -extern GrB_BinaryOp GxB_ISGE_UINT64; -extern GrB_BinaryOp GxB_ISGT_BOOL; -extern GrB_BinaryOp GxB_ISGT_FP32; -extern GrB_BinaryOp GxB_ISGT_FP64; -extern GrB_BinaryOp GxB_ISGT_INT8; -extern GrB_BinaryOp GxB_ISGT_INT16; -extern GrB_BinaryOp GxB_ISGT_INT32; -extern GrB_BinaryOp GxB_ISGT_INT64; -extern GrB_BinaryOp GxB_ISGT_UINT8; -extern GrB_BinaryOp GxB_ISGT_UINT16; -extern GrB_BinaryOp GxB_ISGT_UINT32; -extern GrB_BinaryOp GxB_ISGT_UINT64; -extern GrB_BinaryOp GxB_ISLE_BOOL; -extern GrB_BinaryOp GxB_ISLE_FP32; -extern GrB_BinaryOp GxB_ISLE_FP64; -extern GrB_BinaryOp GxB_ISLE_INT8; -extern GrB_BinaryOp GxB_ISLE_INT16; -extern GrB_BinaryOp GxB_ISLE_INT32; -extern GrB_BinaryOp GxB_ISLE_INT64; -extern GrB_BinaryOp GxB_ISLE_UINT8; -extern GrB_BinaryOp GxB_ISLE_UINT16; -extern GrB_BinaryOp GxB_ISLE_UINT32; -extern GrB_BinaryOp GxB_ISLE_UINT64; -extern GrB_BinaryOp GxB_ISLT_BOOL; -extern GrB_BinaryOp GxB_ISLT_FP32; -extern GrB_BinaryOp GxB_ISLT_FP64; -extern GrB_BinaryOp GxB_ISLT_INT8; -extern GrB_BinaryOp GxB_ISLT_INT16; -extern GrB_BinaryOp GxB_ISLT_INT32; -extern GrB_BinaryOp GxB_ISLT_INT64; -extern GrB_BinaryOp GxB_ISLT_UINT8; -extern GrB_BinaryOp GxB_ISLT_UINT16; -extern GrB_BinaryOp GxB_ISLT_UINT32; -extern GrB_BinaryOp GxB_ISLT_UINT64; -extern GrB_BinaryOp GxB_ISNE_BOOL; -extern GrB_BinaryOp GxB_ISNE_FC32; -extern GrB_BinaryOp GxB_ISNE_FC64; -extern GrB_BinaryOp GxB_ISNE_FP32; -extern GrB_BinaryOp GxB_ISNE_FP64; -extern GrB_BinaryOp GxB_ISNE_INT8; -extern GrB_BinaryOp GxB_ISNE_INT16; -extern GrB_BinaryOp GxB_ISNE_INT32; -extern GrB_BinaryOp GxB_ISNE_INT64; -extern GrB_BinaryOp GxB_ISNE_UINT8; -extern GrB_BinaryOp GxB_ISNE_UINT16; -extern GrB_BinaryOp GxB_ISNE_UINT32; -extern GrB_BinaryOp GxB_ISNE_UINT64; -extern GrB_BinaryOp GxB_LAND_BOOL; -extern GrB_BinaryOp GxB_LAND_FP32; -extern GrB_BinaryOp GxB_LAND_FP64; -extern GrB_BinaryOp GxB_LAND_INT8; -extern GrB_BinaryOp GxB_LAND_INT16; -extern GrB_BinaryOp GxB_LAND_INT32; -extern GrB_BinaryOp GxB_LAND_INT64; -extern GrB_BinaryOp GxB_LAND_UINT8; -extern GrB_BinaryOp GxB_LAND_UINT16; -extern GrB_BinaryOp GxB_LAND_UINT32; -extern GrB_BinaryOp GxB_LAND_UINT64; -extern GrB_BinaryOp GxB_LDEXP_FP32; -extern GrB_BinaryOp GxB_LDEXP_FP64; -extern GrB_BinaryOp GxB_LOR_BOOL; -extern GrB_BinaryOp GxB_LOR_FP32; -extern GrB_BinaryOp GxB_LOR_FP64; -extern GrB_BinaryOp GxB_LOR_INT8; -extern GrB_BinaryOp GxB_LOR_INT16; -extern GrB_BinaryOp GxB_LOR_INT32; -extern GrB_BinaryOp GxB_LOR_INT64; -extern GrB_BinaryOp GxB_LOR_UINT8; -extern GrB_BinaryOp GxB_LOR_UINT16; -extern GrB_BinaryOp GxB_LOR_UINT32; -extern GrB_BinaryOp GxB_LOR_UINT64; -extern GrB_BinaryOp GxB_LXOR_BOOL; -extern GrB_BinaryOp GxB_LXOR_FP32; -extern GrB_BinaryOp GxB_LXOR_FP64; -extern GrB_BinaryOp GxB_LXOR_INT8; -extern GrB_BinaryOp GxB_LXOR_INT16; -extern GrB_BinaryOp GxB_LXOR_INT32; -extern GrB_BinaryOp GxB_LXOR_INT64; -extern GrB_BinaryOp GxB_LXOR_UINT8; -extern GrB_BinaryOp GxB_LXOR_UINT16; -extern GrB_BinaryOp GxB_LXOR_UINT32; -extern GrB_BinaryOp GxB_LXOR_UINT64; -extern GrB_BinaryOp GxB_MINUS_FC32; -extern GrB_BinaryOp GxB_MINUS_FC64; -extern GrB_BinaryOp GxB_NE_FC32; -extern GrB_BinaryOp GxB_NE_FC64; -extern GrB_BinaryOp GxB_PAIR_BOOL; -extern GrB_BinaryOp GxB_PAIR_FC32; -extern GrB_BinaryOp GxB_PAIR_FC64; -extern GrB_BinaryOp GxB_PAIR_FP32; -extern GrB_BinaryOp GxB_PAIR_FP64; -extern GrB_BinaryOp GxB_PAIR_INT8; -extern GrB_BinaryOp GxB_PAIR_INT16; -extern GrB_BinaryOp GxB_PAIR_INT32; -extern GrB_BinaryOp GxB_PAIR_INT64; -extern GrB_BinaryOp GxB_PAIR_UINT8; -extern GrB_BinaryOp GxB_PAIR_UINT16; -extern GrB_BinaryOp GxB_PAIR_UINT32; -extern GrB_BinaryOp GxB_PAIR_UINT64; -extern GrB_BinaryOp GxB_PLUS_FC32; -extern GrB_BinaryOp GxB_PLUS_FC64; -extern GrB_BinaryOp GxB_POW_BOOL; -extern GrB_BinaryOp GxB_POW_FC32; -extern GrB_BinaryOp GxB_POW_FC64; -extern GrB_BinaryOp GxB_POW_FP32; -extern GrB_BinaryOp GxB_POW_FP64; -extern GrB_BinaryOp GxB_POW_INT8; -extern GrB_BinaryOp GxB_POW_INT16; -extern GrB_BinaryOp GxB_POW_INT32; -extern GrB_BinaryOp GxB_POW_INT64; -extern GrB_BinaryOp GxB_POW_UINT8; -extern GrB_BinaryOp GxB_POW_UINT16; -extern GrB_BinaryOp GxB_POW_UINT32; -extern GrB_BinaryOp GxB_POW_UINT64; -extern GrB_BinaryOp GxB_RDIV_BOOL; -extern GrB_BinaryOp GxB_RDIV_FC32; -extern GrB_BinaryOp GxB_RDIV_FC64; -extern GrB_BinaryOp GxB_RDIV_FP32; -extern GrB_BinaryOp GxB_RDIV_FP64; -extern GrB_BinaryOp GxB_RDIV_INT8; -extern GrB_BinaryOp GxB_RDIV_INT16; -extern GrB_BinaryOp GxB_RDIV_INT32; -extern GrB_BinaryOp GxB_RDIV_INT64; -extern GrB_BinaryOp GxB_RDIV_UINT8; -extern GrB_BinaryOp GxB_RDIV_UINT16; -extern GrB_BinaryOp GxB_RDIV_UINT32; -extern GrB_BinaryOp GxB_RDIV_UINT64; -extern GrB_BinaryOp GxB_REMAINDER_FP32; -extern GrB_BinaryOp GxB_REMAINDER_FP64; -extern GrB_BinaryOp GxB_RMINUS_BOOL; -extern GrB_BinaryOp GxB_RMINUS_FC32; -extern GrB_BinaryOp GxB_RMINUS_FC64; -extern GrB_BinaryOp GxB_RMINUS_FP32; -extern GrB_BinaryOp GxB_RMINUS_FP64; -extern GrB_BinaryOp GxB_RMINUS_INT8; -extern GrB_BinaryOp GxB_RMINUS_INT16; -extern GrB_BinaryOp GxB_RMINUS_INT32; -extern GrB_BinaryOp GxB_RMINUS_INT64; -extern GrB_BinaryOp GxB_RMINUS_UINT8; -extern GrB_BinaryOp GxB_RMINUS_UINT16; -extern GrB_BinaryOp GxB_RMINUS_UINT32; -extern GrB_BinaryOp GxB_RMINUS_UINT64; -extern GrB_BinaryOp GxB_SECONDI1_INT32; -extern GrB_BinaryOp GxB_SECONDI1_INT64; -extern GrB_BinaryOp GxB_SECONDI_INT32; -extern GrB_BinaryOp GxB_SECONDI_INT64; -extern GrB_BinaryOp GxB_SECONDJ1_INT32; -extern GrB_BinaryOp GxB_SECONDJ1_INT64; -extern GrB_BinaryOp GxB_SECONDJ_INT32; -extern GrB_BinaryOp GxB_SECONDJ_INT64; -extern GrB_BinaryOp GxB_SECOND_FC32; -extern GrB_BinaryOp GxB_SECOND_FC64; -extern GrB_BinaryOp GxB_TIMES_FC32; -extern GrB_BinaryOp GxB_TIMES_FC64; -extern GrB_Monoid GxB_ANY_BOOL_MONOID; -extern GrB_Monoid GxB_ANY_FC32_MONOID; -extern GrB_Monoid GxB_ANY_FC64_MONOID; -extern GrB_Monoid GxB_ANY_FP32_MONOID; -extern GrB_Monoid GxB_ANY_FP64_MONOID; -extern GrB_Monoid GxB_ANY_INT8_MONOID; -extern GrB_Monoid GxB_ANY_INT16_MONOID; -extern GrB_Monoid GxB_ANY_INT32_MONOID; -extern GrB_Monoid GxB_ANY_INT64_MONOID; -extern GrB_Monoid GxB_ANY_UINT8_MONOID; -extern GrB_Monoid GxB_ANY_UINT16_MONOID; -extern GrB_Monoid GxB_ANY_UINT32_MONOID; -extern GrB_Monoid GxB_ANY_UINT64_MONOID; -extern GrB_Monoid GxB_BAND_UINT8_MONOID; -extern GrB_Monoid GxB_BAND_UINT16_MONOID; -extern GrB_Monoid GxB_BAND_UINT32_MONOID; -extern GrB_Monoid GxB_BAND_UINT64_MONOID; -extern GrB_Monoid GxB_BOR_UINT8_MONOID; -extern GrB_Monoid GxB_BOR_UINT16_MONOID; -extern GrB_Monoid GxB_BOR_UINT32_MONOID; -extern GrB_Monoid GxB_BOR_UINT64_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT8_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT16_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT32_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT64_MONOID; -extern GrB_Monoid GxB_BXOR_UINT8_MONOID; -extern GrB_Monoid GxB_BXOR_UINT16_MONOID; -extern GrB_Monoid GxB_BXOR_UINT32_MONOID; -extern GrB_Monoid GxB_BXOR_UINT64_MONOID; -extern GrB_Monoid GxB_EQ_BOOL_MONOID; -extern GrB_Monoid GxB_PLUS_FC32_MONOID; -extern GrB_Monoid GxB_PLUS_FC64_MONOID; -extern GrB_Monoid GxB_TIMES_FC32_MONOID; -extern GrB_Monoid GxB_TIMES_FC64_MONOID; -extern GrB_Semiring GxB_ANY_DIV_FC32; -extern GrB_Semiring GxB_ANY_DIV_FC64; -extern GrB_Semiring GxB_ANY_DIV_FP32; -extern GrB_Semiring GxB_ANY_DIV_FP64; -extern GrB_Semiring GxB_ANY_DIV_INT8; -extern GrB_Semiring GxB_ANY_DIV_INT16; -extern GrB_Semiring GxB_ANY_DIV_INT32; -extern GrB_Semiring GxB_ANY_DIV_INT64; -extern GrB_Semiring GxB_ANY_DIV_UINT8; -extern GrB_Semiring GxB_ANY_DIV_UINT16; -extern GrB_Semiring GxB_ANY_DIV_UINT32; -extern GrB_Semiring GxB_ANY_DIV_UINT64; -extern GrB_Semiring GxB_ANY_EQ_BOOL; -extern GrB_Semiring GxB_ANY_EQ_FP32; -extern GrB_Semiring GxB_ANY_EQ_FP64; -extern GrB_Semiring GxB_ANY_EQ_INT8; -extern GrB_Semiring GxB_ANY_EQ_INT16; -extern GrB_Semiring GxB_ANY_EQ_INT32; -extern GrB_Semiring GxB_ANY_EQ_INT64; -extern GrB_Semiring GxB_ANY_EQ_UINT8; -extern GrB_Semiring GxB_ANY_EQ_UINT16; -extern GrB_Semiring GxB_ANY_EQ_UINT32; -extern GrB_Semiring GxB_ANY_EQ_UINT64; -extern GrB_Semiring GxB_ANY_FIRSTI1_INT32; -extern GrB_Semiring GxB_ANY_FIRSTI1_INT64; -extern GrB_Semiring GxB_ANY_FIRSTI_INT32; -extern GrB_Semiring GxB_ANY_FIRSTI_INT64; -extern GrB_Semiring GxB_ANY_FIRSTJ1_INT32; -extern GrB_Semiring GxB_ANY_FIRSTJ1_INT64; -extern GrB_Semiring GxB_ANY_FIRSTJ_INT32; -extern GrB_Semiring GxB_ANY_FIRSTJ_INT64; -extern GrB_Semiring GxB_ANY_FIRST_BOOL; -extern GrB_Semiring GxB_ANY_FIRST_FC32; -extern GrB_Semiring GxB_ANY_FIRST_FC64; -extern GrB_Semiring GxB_ANY_FIRST_FP32; -extern GrB_Semiring GxB_ANY_FIRST_FP64; -extern GrB_Semiring GxB_ANY_FIRST_INT8; -extern GrB_Semiring GxB_ANY_FIRST_INT16; -extern GrB_Semiring GxB_ANY_FIRST_INT32; -extern GrB_Semiring GxB_ANY_FIRST_INT64; -extern GrB_Semiring GxB_ANY_FIRST_UINT8; -extern GrB_Semiring GxB_ANY_FIRST_UINT16; -extern GrB_Semiring GxB_ANY_FIRST_UINT32; -extern GrB_Semiring GxB_ANY_FIRST_UINT64; -extern GrB_Semiring GxB_ANY_GE_BOOL; -extern GrB_Semiring GxB_ANY_GE_FP32; -extern GrB_Semiring GxB_ANY_GE_FP64; -extern GrB_Semiring GxB_ANY_GE_INT8; -extern GrB_Semiring GxB_ANY_GE_INT16; -extern GrB_Semiring GxB_ANY_GE_INT32; -extern GrB_Semiring GxB_ANY_GE_INT64; -extern GrB_Semiring GxB_ANY_GE_UINT8; -extern GrB_Semiring GxB_ANY_GE_UINT16; -extern GrB_Semiring GxB_ANY_GE_UINT32; -extern GrB_Semiring GxB_ANY_GE_UINT64; -extern GrB_Semiring GxB_ANY_GT_BOOL; -extern GrB_Semiring GxB_ANY_GT_FP32; -extern GrB_Semiring GxB_ANY_GT_FP64; -extern GrB_Semiring GxB_ANY_GT_INT8; -extern GrB_Semiring GxB_ANY_GT_INT16; -extern GrB_Semiring GxB_ANY_GT_INT32; -extern GrB_Semiring GxB_ANY_GT_INT64; -extern GrB_Semiring GxB_ANY_GT_UINT8; -extern GrB_Semiring GxB_ANY_GT_UINT16; -extern GrB_Semiring GxB_ANY_GT_UINT32; -extern GrB_Semiring GxB_ANY_GT_UINT64; -extern GrB_Semiring GxB_ANY_ISEQ_FP32; -extern GrB_Semiring GxB_ANY_ISEQ_FP64; -extern GrB_Semiring GxB_ANY_ISEQ_INT8; -extern GrB_Semiring GxB_ANY_ISEQ_INT16; -extern GrB_Semiring GxB_ANY_ISEQ_INT32; -extern GrB_Semiring GxB_ANY_ISEQ_INT64; -extern GrB_Semiring GxB_ANY_ISEQ_UINT8; -extern GrB_Semiring GxB_ANY_ISEQ_UINT16; -extern GrB_Semiring GxB_ANY_ISEQ_UINT32; -extern GrB_Semiring GxB_ANY_ISEQ_UINT64; -extern GrB_Semiring GxB_ANY_ISGE_FP32; -extern GrB_Semiring GxB_ANY_ISGE_FP64; -extern GrB_Semiring GxB_ANY_ISGE_INT8; -extern GrB_Semiring GxB_ANY_ISGE_INT16; -extern GrB_Semiring GxB_ANY_ISGE_INT32; -extern GrB_Semiring GxB_ANY_ISGE_INT64; -extern GrB_Semiring GxB_ANY_ISGE_UINT8; -extern GrB_Semiring GxB_ANY_ISGE_UINT16; -extern GrB_Semiring GxB_ANY_ISGE_UINT32; -extern GrB_Semiring GxB_ANY_ISGE_UINT64; -extern GrB_Semiring GxB_ANY_ISGT_FP32; -extern GrB_Semiring GxB_ANY_ISGT_FP64; -extern GrB_Semiring GxB_ANY_ISGT_INT8; -extern GrB_Semiring GxB_ANY_ISGT_INT16; -extern GrB_Semiring GxB_ANY_ISGT_INT32; -extern GrB_Semiring GxB_ANY_ISGT_INT64; -extern GrB_Semiring GxB_ANY_ISGT_UINT8; -extern GrB_Semiring GxB_ANY_ISGT_UINT16; -extern GrB_Semiring GxB_ANY_ISGT_UINT32; -extern GrB_Semiring GxB_ANY_ISGT_UINT64; -extern GrB_Semiring GxB_ANY_ISLE_FP32; -extern GrB_Semiring GxB_ANY_ISLE_FP64; -extern GrB_Semiring GxB_ANY_ISLE_INT8; -extern GrB_Semiring GxB_ANY_ISLE_INT16; -extern GrB_Semiring GxB_ANY_ISLE_INT32; -extern GrB_Semiring GxB_ANY_ISLE_INT64; -extern GrB_Semiring GxB_ANY_ISLE_UINT8; -extern GrB_Semiring GxB_ANY_ISLE_UINT16; -extern GrB_Semiring GxB_ANY_ISLE_UINT32; -extern GrB_Semiring GxB_ANY_ISLE_UINT64; -extern GrB_Semiring GxB_ANY_ISLT_FP32; -extern GrB_Semiring GxB_ANY_ISLT_FP64; -extern GrB_Semiring GxB_ANY_ISLT_INT8; -extern GrB_Semiring GxB_ANY_ISLT_INT16; -extern GrB_Semiring GxB_ANY_ISLT_INT32; -extern GrB_Semiring GxB_ANY_ISLT_INT64; -extern GrB_Semiring GxB_ANY_ISLT_UINT8; -extern GrB_Semiring GxB_ANY_ISLT_UINT16; -extern GrB_Semiring GxB_ANY_ISLT_UINT32; -extern GrB_Semiring GxB_ANY_ISLT_UINT64; -extern GrB_Semiring GxB_ANY_ISNE_FP32; -extern GrB_Semiring GxB_ANY_ISNE_FP64; -extern GrB_Semiring GxB_ANY_ISNE_INT8; -extern GrB_Semiring GxB_ANY_ISNE_INT16; -extern GrB_Semiring GxB_ANY_ISNE_INT32; -extern GrB_Semiring GxB_ANY_ISNE_INT64; -extern GrB_Semiring GxB_ANY_ISNE_UINT8; -extern GrB_Semiring GxB_ANY_ISNE_UINT16; -extern GrB_Semiring GxB_ANY_ISNE_UINT32; -extern GrB_Semiring GxB_ANY_ISNE_UINT64; -extern GrB_Semiring GxB_ANY_LAND_BOOL; -extern GrB_Semiring GxB_ANY_LAND_FP32; -extern GrB_Semiring GxB_ANY_LAND_FP64; -extern GrB_Semiring GxB_ANY_LAND_INT8; -extern GrB_Semiring GxB_ANY_LAND_INT16; -extern GrB_Semiring GxB_ANY_LAND_INT32; -extern GrB_Semiring GxB_ANY_LAND_INT64; -extern GrB_Semiring GxB_ANY_LAND_UINT8; -extern GrB_Semiring GxB_ANY_LAND_UINT16; -extern GrB_Semiring GxB_ANY_LAND_UINT32; -extern GrB_Semiring GxB_ANY_LAND_UINT64; -extern GrB_Semiring GxB_ANY_LE_BOOL; -extern GrB_Semiring GxB_ANY_LE_FP32; -extern GrB_Semiring GxB_ANY_LE_FP64; -extern GrB_Semiring GxB_ANY_LE_INT8; -extern GrB_Semiring GxB_ANY_LE_INT16; -extern GrB_Semiring GxB_ANY_LE_INT32; -extern GrB_Semiring GxB_ANY_LE_INT64; -extern GrB_Semiring GxB_ANY_LE_UINT8; -extern GrB_Semiring GxB_ANY_LE_UINT16; -extern GrB_Semiring GxB_ANY_LE_UINT32; -extern GrB_Semiring GxB_ANY_LE_UINT64; -extern GrB_Semiring GxB_ANY_LOR_BOOL; -extern GrB_Semiring GxB_ANY_LOR_FP32; -extern GrB_Semiring GxB_ANY_LOR_FP64; -extern GrB_Semiring GxB_ANY_LOR_INT8; -extern GrB_Semiring GxB_ANY_LOR_INT16; -extern GrB_Semiring GxB_ANY_LOR_INT32; -extern GrB_Semiring GxB_ANY_LOR_INT64; -extern GrB_Semiring GxB_ANY_LOR_UINT8; -extern GrB_Semiring GxB_ANY_LOR_UINT16; -extern GrB_Semiring GxB_ANY_LOR_UINT32; -extern GrB_Semiring GxB_ANY_LOR_UINT64; -extern GrB_Semiring GxB_ANY_LT_BOOL; -extern GrB_Semiring GxB_ANY_LT_FP32; -extern GrB_Semiring GxB_ANY_LT_FP64; -extern GrB_Semiring GxB_ANY_LT_INT8; -extern GrB_Semiring GxB_ANY_LT_INT16; -extern GrB_Semiring GxB_ANY_LT_INT32; -extern GrB_Semiring GxB_ANY_LT_INT64; -extern GrB_Semiring GxB_ANY_LT_UINT8; -extern GrB_Semiring GxB_ANY_LT_UINT16; -extern GrB_Semiring GxB_ANY_LT_UINT32; -extern GrB_Semiring GxB_ANY_LT_UINT64; -extern GrB_Semiring GxB_ANY_LXOR_BOOL; -extern GrB_Semiring GxB_ANY_LXOR_FP32; -extern GrB_Semiring GxB_ANY_LXOR_FP64; -extern GrB_Semiring GxB_ANY_LXOR_INT8; -extern GrB_Semiring GxB_ANY_LXOR_INT16; -extern GrB_Semiring GxB_ANY_LXOR_INT32; -extern GrB_Semiring GxB_ANY_LXOR_INT64; -extern GrB_Semiring GxB_ANY_LXOR_UINT8; -extern GrB_Semiring GxB_ANY_LXOR_UINT16; -extern GrB_Semiring GxB_ANY_LXOR_UINT32; -extern GrB_Semiring GxB_ANY_LXOR_UINT64; -extern GrB_Semiring GxB_ANY_MAX_FP32; -extern GrB_Semiring GxB_ANY_MAX_FP64; -extern GrB_Semiring GxB_ANY_MAX_INT8; -extern GrB_Semiring GxB_ANY_MAX_INT16; -extern GrB_Semiring GxB_ANY_MAX_INT32; -extern GrB_Semiring GxB_ANY_MAX_INT64; -extern GrB_Semiring GxB_ANY_MAX_UINT8; -extern GrB_Semiring GxB_ANY_MAX_UINT16; -extern GrB_Semiring GxB_ANY_MAX_UINT32; -extern GrB_Semiring GxB_ANY_MAX_UINT64; -extern GrB_Semiring GxB_ANY_MINUS_FC32; -extern GrB_Semiring GxB_ANY_MINUS_FC64; -extern GrB_Semiring GxB_ANY_MINUS_FP32; -extern GrB_Semiring GxB_ANY_MINUS_FP64; -extern GrB_Semiring GxB_ANY_MINUS_INT8; -extern GrB_Semiring GxB_ANY_MINUS_INT16; -extern GrB_Semiring GxB_ANY_MINUS_INT32; -extern GrB_Semiring GxB_ANY_MINUS_INT64; -extern GrB_Semiring GxB_ANY_MINUS_UINT8; -extern GrB_Semiring GxB_ANY_MINUS_UINT16; -extern GrB_Semiring GxB_ANY_MINUS_UINT32; -extern GrB_Semiring GxB_ANY_MINUS_UINT64; -extern GrB_Semiring GxB_ANY_MIN_FP32; -extern GrB_Semiring GxB_ANY_MIN_FP64; -extern GrB_Semiring GxB_ANY_MIN_INT8; -extern GrB_Semiring GxB_ANY_MIN_INT16; -extern GrB_Semiring GxB_ANY_MIN_INT32; -extern GrB_Semiring GxB_ANY_MIN_INT64; -extern GrB_Semiring GxB_ANY_MIN_UINT8; -extern GrB_Semiring GxB_ANY_MIN_UINT16; -extern GrB_Semiring GxB_ANY_MIN_UINT32; -extern GrB_Semiring GxB_ANY_MIN_UINT64; -extern GrB_Semiring GxB_ANY_NE_FP32; -extern GrB_Semiring GxB_ANY_NE_FP64; -extern GrB_Semiring GxB_ANY_NE_INT8; -extern GrB_Semiring GxB_ANY_NE_INT16; -extern GrB_Semiring GxB_ANY_NE_INT32; -extern GrB_Semiring GxB_ANY_NE_INT64; -extern GrB_Semiring GxB_ANY_NE_UINT8; -extern GrB_Semiring GxB_ANY_NE_UINT16; -extern GrB_Semiring GxB_ANY_NE_UINT32; -extern GrB_Semiring GxB_ANY_NE_UINT64; -extern GrB_Semiring GxB_ANY_PAIR_BOOL; -extern GrB_Semiring GxB_ANY_PAIR_FC32; -extern GrB_Semiring GxB_ANY_PAIR_FC64; -extern GrB_Semiring GxB_ANY_PAIR_FP32; -extern GrB_Semiring GxB_ANY_PAIR_FP64; -extern GrB_Semiring GxB_ANY_PAIR_INT8; -extern GrB_Semiring GxB_ANY_PAIR_INT16; -extern GrB_Semiring GxB_ANY_PAIR_INT32; -extern GrB_Semiring GxB_ANY_PAIR_INT64; -extern GrB_Semiring GxB_ANY_PAIR_UINT8; -extern GrB_Semiring GxB_ANY_PAIR_UINT16; -extern GrB_Semiring GxB_ANY_PAIR_UINT32; -extern GrB_Semiring GxB_ANY_PAIR_UINT64; -extern GrB_Semiring GxB_ANY_PLUS_FC32; -extern GrB_Semiring GxB_ANY_PLUS_FC64; -extern GrB_Semiring GxB_ANY_PLUS_FP32; -extern GrB_Semiring GxB_ANY_PLUS_FP64; -extern GrB_Semiring GxB_ANY_PLUS_INT8; -extern GrB_Semiring GxB_ANY_PLUS_INT16; -extern GrB_Semiring GxB_ANY_PLUS_INT32; -extern GrB_Semiring GxB_ANY_PLUS_INT64; -extern GrB_Semiring GxB_ANY_PLUS_UINT8; -extern GrB_Semiring GxB_ANY_PLUS_UINT16; -extern GrB_Semiring GxB_ANY_PLUS_UINT32; -extern GrB_Semiring GxB_ANY_PLUS_UINT64; -extern GrB_Semiring GxB_ANY_RDIV_FC32; -extern GrB_Semiring GxB_ANY_RDIV_FC64; -extern GrB_Semiring GxB_ANY_RDIV_FP32; -extern GrB_Semiring GxB_ANY_RDIV_FP64; -extern GrB_Semiring GxB_ANY_RDIV_INT8; -extern GrB_Semiring GxB_ANY_RDIV_INT16; -extern GrB_Semiring GxB_ANY_RDIV_INT32; -extern GrB_Semiring GxB_ANY_RDIV_INT64; -extern GrB_Semiring GxB_ANY_RDIV_UINT8; -extern GrB_Semiring GxB_ANY_RDIV_UINT16; -extern GrB_Semiring GxB_ANY_RDIV_UINT32; -extern GrB_Semiring GxB_ANY_RDIV_UINT64; -extern GrB_Semiring GxB_ANY_RMINUS_FC32; -extern GrB_Semiring GxB_ANY_RMINUS_FC64; -extern GrB_Semiring GxB_ANY_RMINUS_FP32; -extern GrB_Semiring GxB_ANY_RMINUS_FP64; -extern GrB_Semiring GxB_ANY_RMINUS_INT8; -extern GrB_Semiring GxB_ANY_RMINUS_INT16; -extern GrB_Semiring GxB_ANY_RMINUS_INT32; -extern GrB_Semiring GxB_ANY_RMINUS_INT64; -extern GrB_Semiring GxB_ANY_RMINUS_UINT8; -extern GrB_Semiring GxB_ANY_RMINUS_UINT16; -extern GrB_Semiring GxB_ANY_RMINUS_UINT32; -extern GrB_Semiring GxB_ANY_RMINUS_UINT64; -extern GrB_Semiring GxB_ANY_SECONDI1_INT32; -extern GrB_Semiring GxB_ANY_SECONDI1_INT64; -extern GrB_Semiring GxB_ANY_SECONDI_INT32; -extern GrB_Semiring GxB_ANY_SECONDI_INT64; -extern GrB_Semiring GxB_ANY_SECONDJ1_INT32; -extern GrB_Semiring GxB_ANY_SECONDJ1_INT64; -extern GrB_Semiring GxB_ANY_SECONDJ_INT32; -extern GrB_Semiring GxB_ANY_SECONDJ_INT64; -extern GrB_Semiring GxB_ANY_SECOND_BOOL; -extern GrB_Semiring GxB_ANY_SECOND_FC32; -extern GrB_Semiring GxB_ANY_SECOND_FC64; -extern GrB_Semiring GxB_ANY_SECOND_FP32; -extern GrB_Semiring GxB_ANY_SECOND_FP64; -extern GrB_Semiring GxB_ANY_SECOND_INT8; -extern GrB_Semiring GxB_ANY_SECOND_INT16; -extern GrB_Semiring GxB_ANY_SECOND_INT32; -extern GrB_Semiring GxB_ANY_SECOND_INT64; -extern GrB_Semiring GxB_ANY_SECOND_UINT8; -extern GrB_Semiring GxB_ANY_SECOND_UINT16; -extern GrB_Semiring GxB_ANY_SECOND_UINT32; -extern GrB_Semiring GxB_ANY_SECOND_UINT64; -extern GrB_Semiring GxB_ANY_TIMES_FC32; -extern GrB_Semiring GxB_ANY_TIMES_FC64; -extern GrB_Semiring GxB_ANY_TIMES_FP32; -extern GrB_Semiring GxB_ANY_TIMES_FP64; -extern GrB_Semiring GxB_ANY_TIMES_INT8; -extern GrB_Semiring GxB_ANY_TIMES_INT16; -extern GrB_Semiring GxB_ANY_TIMES_INT32; -extern GrB_Semiring GxB_ANY_TIMES_INT64; -extern GrB_Semiring GxB_ANY_TIMES_UINT8; -extern GrB_Semiring GxB_ANY_TIMES_UINT16; -extern GrB_Semiring GxB_ANY_TIMES_UINT32; -extern GrB_Semiring GxB_ANY_TIMES_UINT64; -extern GrB_Semiring GxB_BAND_BAND_UINT8; -extern GrB_Semiring GxB_BAND_BAND_UINT16; -extern GrB_Semiring GxB_BAND_BAND_UINT32; -extern GrB_Semiring GxB_BAND_BAND_UINT64; -extern GrB_Semiring GxB_BAND_BOR_UINT8; -extern GrB_Semiring GxB_BAND_BOR_UINT16; -extern GrB_Semiring GxB_BAND_BOR_UINT32; -extern GrB_Semiring GxB_BAND_BOR_UINT64; -extern GrB_Semiring GxB_BAND_BXNOR_UINT8; -extern GrB_Semiring GxB_BAND_BXNOR_UINT16; -extern GrB_Semiring GxB_BAND_BXNOR_UINT32; -extern GrB_Semiring GxB_BAND_BXNOR_UINT64; -extern GrB_Semiring GxB_BAND_BXOR_UINT8; -extern GrB_Semiring GxB_BAND_BXOR_UINT16; -extern GrB_Semiring GxB_BAND_BXOR_UINT32; -extern GrB_Semiring GxB_BAND_BXOR_UINT64; -extern GrB_Semiring GxB_BOR_BAND_UINT8; -extern GrB_Semiring GxB_BOR_BAND_UINT16; -extern GrB_Semiring GxB_BOR_BAND_UINT32; -extern GrB_Semiring GxB_BOR_BAND_UINT64; -extern GrB_Semiring GxB_BOR_BOR_UINT8; -extern GrB_Semiring GxB_BOR_BOR_UINT16; -extern GrB_Semiring GxB_BOR_BOR_UINT32; -extern GrB_Semiring GxB_BOR_BOR_UINT64; -extern GrB_Semiring GxB_BOR_BXNOR_UINT8; -extern GrB_Semiring GxB_BOR_BXNOR_UINT16; -extern GrB_Semiring GxB_BOR_BXNOR_UINT32; -extern GrB_Semiring GxB_BOR_BXNOR_UINT64; -extern GrB_Semiring GxB_BOR_BXOR_UINT8; -extern GrB_Semiring GxB_BOR_BXOR_UINT16; -extern GrB_Semiring GxB_BOR_BXOR_UINT32; -extern GrB_Semiring GxB_BOR_BXOR_UINT64; -extern GrB_Semiring GxB_BXNOR_BAND_UINT8; -extern GrB_Semiring GxB_BXNOR_BAND_UINT16; -extern GrB_Semiring GxB_BXNOR_BAND_UINT32; -extern GrB_Semiring GxB_BXNOR_BAND_UINT64; -extern GrB_Semiring GxB_BXNOR_BOR_UINT8; -extern GrB_Semiring GxB_BXNOR_BOR_UINT16; -extern GrB_Semiring GxB_BXNOR_BOR_UINT32; -extern GrB_Semiring GxB_BXNOR_BOR_UINT64; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT8; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT16; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT32; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT64; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT8; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT16; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT32; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT64; -extern GrB_Semiring GxB_BXOR_BAND_UINT8; -extern GrB_Semiring GxB_BXOR_BAND_UINT16; -extern GrB_Semiring GxB_BXOR_BAND_UINT32; -extern GrB_Semiring GxB_BXOR_BAND_UINT64; -extern GrB_Semiring GxB_BXOR_BOR_UINT8; -extern GrB_Semiring GxB_BXOR_BOR_UINT16; -extern GrB_Semiring GxB_BXOR_BOR_UINT32; -extern GrB_Semiring GxB_BXOR_BOR_UINT64; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT8; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT16; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT32; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT64; -extern GrB_Semiring GxB_BXOR_BXOR_UINT8; -extern GrB_Semiring GxB_BXOR_BXOR_UINT16; -extern GrB_Semiring GxB_BXOR_BXOR_UINT32; -extern GrB_Semiring GxB_BXOR_BXOR_UINT64; -extern GrB_Semiring GxB_EQ_EQ_BOOL; -extern GrB_Semiring GxB_EQ_EQ_FP32; -extern GrB_Semiring GxB_EQ_EQ_FP64; -extern GrB_Semiring GxB_EQ_EQ_INT8; -extern GrB_Semiring GxB_EQ_EQ_INT16; -extern GrB_Semiring GxB_EQ_EQ_INT32; -extern GrB_Semiring GxB_EQ_EQ_INT64; -extern GrB_Semiring GxB_EQ_EQ_UINT8; -extern GrB_Semiring GxB_EQ_EQ_UINT16; -extern GrB_Semiring GxB_EQ_EQ_UINT32; -extern GrB_Semiring GxB_EQ_EQ_UINT64; -extern GrB_Semiring GxB_EQ_FIRST_BOOL; -extern GrB_Semiring GxB_EQ_GE_BOOL; -extern GrB_Semiring GxB_EQ_GE_FP32; -extern GrB_Semiring GxB_EQ_GE_FP64; -extern GrB_Semiring GxB_EQ_GE_INT8; -extern GrB_Semiring GxB_EQ_GE_INT16; -extern GrB_Semiring GxB_EQ_GE_INT32; -extern GrB_Semiring GxB_EQ_GE_INT64; -extern GrB_Semiring GxB_EQ_GE_UINT8; -extern GrB_Semiring GxB_EQ_GE_UINT16; -extern GrB_Semiring GxB_EQ_GE_UINT32; -extern GrB_Semiring GxB_EQ_GE_UINT64; -extern GrB_Semiring GxB_EQ_GT_BOOL; -extern GrB_Semiring GxB_EQ_GT_FP32; -extern GrB_Semiring GxB_EQ_GT_FP64; -extern GrB_Semiring GxB_EQ_GT_INT8; -extern GrB_Semiring GxB_EQ_GT_INT16; -extern GrB_Semiring GxB_EQ_GT_INT32; -extern GrB_Semiring GxB_EQ_GT_INT64; -extern GrB_Semiring GxB_EQ_GT_UINT8; -extern GrB_Semiring GxB_EQ_GT_UINT16; -extern GrB_Semiring GxB_EQ_GT_UINT32; -extern GrB_Semiring GxB_EQ_GT_UINT64; -extern GrB_Semiring GxB_EQ_LAND_BOOL; -extern GrB_Semiring GxB_EQ_LE_BOOL; -extern GrB_Semiring GxB_EQ_LE_FP32; -extern GrB_Semiring GxB_EQ_LE_FP64; -extern GrB_Semiring GxB_EQ_LE_INT8; -extern GrB_Semiring GxB_EQ_LE_INT16; -extern GrB_Semiring GxB_EQ_LE_INT32; -extern GrB_Semiring GxB_EQ_LE_INT64; -extern GrB_Semiring GxB_EQ_LE_UINT8; -extern GrB_Semiring GxB_EQ_LE_UINT16; -extern GrB_Semiring GxB_EQ_LE_UINT32; -extern GrB_Semiring GxB_EQ_LE_UINT64; -extern GrB_Semiring GxB_EQ_LOR_BOOL; -extern GrB_Semiring GxB_EQ_LT_BOOL; -extern GrB_Semiring GxB_EQ_LT_FP32; -extern GrB_Semiring GxB_EQ_LT_FP64; -extern GrB_Semiring GxB_EQ_LT_INT8; -extern GrB_Semiring GxB_EQ_LT_INT16; -extern GrB_Semiring GxB_EQ_LT_INT32; -extern GrB_Semiring GxB_EQ_LT_INT64; -extern GrB_Semiring GxB_EQ_LT_UINT8; -extern GrB_Semiring GxB_EQ_LT_UINT16; -extern GrB_Semiring GxB_EQ_LT_UINT32; -extern GrB_Semiring GxB_EQ_LT_UINT64; -extern GrB_Semiring GxB_EQ_LXOR_BOOL; -extern GrB_Semiring GxB_EQ_NE_FP32; -extern GrB_Semiring GxB_EQ_NE_FP64; -extern GrB_Semiring GxB_EQ_NE_INT8; -extern GrB_Semiring GxB_EQ_NE_INT16; -extern GrB_Semiring GxB_EQ_NE_INT32; -extern GrB_Semiring GxB_EQ_NE_INT64; -extern GrB_Semiring GxB_EQ_NE_UINT8; -extern GrB_Semiring GxB_EQ_NE_UINT16; -extern GrB_Semiring GxB_EQ_NE_UINT32; -extern GrB_Semiring GxB_EQ_NE_UINT64; -extern GrB_Semiring GxB_EQ_PAIR_BOOL; -extern GrB_Semiring GxB_EQ_SECOND_BOOL; -extern GrB_Semiring GxB_LAND_EQ_BOOL; -extern GrB_Semiring GxB_LAND_EQ_FP32; -extern GrB_Semiring GxB_LAND_EQ_FP64; -extern GrB_Semiring GxB_LAND_EQ_INT8; -extern GrB_Semiring GxB_LAND_EQ_INT16; -extern GrB_Semiring GxB_LAND_EQ_INT32; -extern GrB_Semiring GxB_LAND_EQ_INT64; -extern GrB_Semiring GxB_LAND_EQ_UINT8; -extern GrB_Semiring GxB_LAND_EQ_UINT16; -extern GrB_Semiring GxB_LAND_EQ_UINT32; -extern GrB_Semiring GxB_LAND_EQ_UINT64; -extern GrB_Semiring GxB_LAND_FIRST_BOOL; -extern GrB_Semiring GxB_LAND_GE_BOOL; -extern GrB_Semiring GxB_LAND_GE_FP32; -extern GrB_Semiring GxB_LAND_GE_FP64; -extern GrB_Semiring GxB_LAND_GE_INT8; -extern GrB_Semiring GxB_LAND_GE_INT16; -extern GrB_Semiring GxB_LAND_GE_INT32; -extern GrB_Semiring GxB_LAND_GE_INT64; -extern GrB_Semiring GxB_LAND_GE_UINT8; -extern GrB_Semiring GxB_LAND_GE_UINT16; -extern GrB_Semiring GxB_LAND_GE_UINT32; -extern GrB_Semiring GxB_LAND_GE_UINT64; -extern GrB_Semiring GxB_LAND_GT_BOOL; -extern GrB_Semiring GxB_LAND_GT_FP32; -extern GrB_Semiring GxB_LAND_GT_FP64; -extern GrB_Semiring GxB_LAND_GT_INT8; -extern GrB_Semiring GxB_LAND_GT_INT16; -extern GrB_Semiring GxB_LAND_GT_INT32; -extern GrB_Semiring GxB_LAND_GT_INT64; -extern GrB_Semiring GxB_LAND_GT_UINT8; -extern GrB_Semiring GxB_LAND_GT_UINT16; -extern GrB_Semiring GxB_LAND_GT_UINT32; -extern GrB_Semiring GxB_LAND_GT_UINT64; -extern GrB_Semiring GxB_LAND_LAND_BOOL; -extern GrB_Semiring GxB_LAND_LE_BOOL; -extern GrB_Semiring GxB_LAND_LE_FP32; -extern GrB_Semiring GxB_LAND_LE_FP64; -extern GrB_Semiring GxB_LAND_LE_INT8; -extern GrB_Semiring GxB_LAND_LE_INT16; -extern GrB_Semiring GxB_LAND_LE_INT32; -extern GrB_Semiring GxB_LAND_LE_INT64; -extern GrB_Semiring GxB_LAND_LE_UINT8; -extern GrB_Semiring GxB_LAND_LE_UINT16; -extern GrB_Semiring GxB_LAND_LE_UINT32; -extern GrB_Semiring GxB_LAND_LE_UINT64; -extern GrB_Semiring GxB_LAND_LT_BOOL; -extern GrB_Semiring GxB_LAND_LT_FP32; -extern GrB_Semiring GxB_LAND_LT_FP64; -extern GrB_Semiring GxB_LAND_LT_INT8; -extern GrB_Semiring GxB_LAND_LT_INT16; -extern GrB_Semiring GxB_LAND_LT_INT32; -extern GrB_Semiring GxB_LAND_LT_INT64; -extern GrB_Semiring GxB_LAND_LT_UINT8; -extern GrB_Semiring GxB_LAND_LT_UINT16; -extern GrB_Semiring GxB_LAND_LT_UINT32; -extern GrB_Semiring GxB_LAND_LT_UINT64; -extern GrB_Semiring GxB_LAND_LXOR_BOOL; -extern GrB_Semiring GxB_LAND_NE_FP32; -extern GrB_Semiring GxB_LAND_NE_FP64; -extern GrB_Semiring GxB_LAND_NE_INT8; -extern GrB_Semiring GxB_LAND_NE_INT16; -extern GrB_Semiring GxB_LAND_NE_INT32; -extern GrB_Semiring GxB_LAND_NE_INT64; -extern GrB_Semiring GxB_LAND_NE_UINT8; -extern GrB_Semiring GxB_LAND_NE_UINT16; -extern GrB_Semiring GxB_LAND_NE_UINT32; -extern GrB_Semiring GxB_LAND_NE_UINT64; -extern GrB_Semiring GxB_LAND_PAIR_BOOL; -extern GrB_Semiring GxB_LAND_SECOND_BOOL; -extern GrB_Semiring GxB_LOR_EQ_BOOL; -extern GrB_Semiring GxB_LOR_EQ_FP32; -extern GrB_Semiring GxB_LOR_EQ_FP64; -extern GrB_Semiring GxB_LOR_EQ_INT8; -extern GrB_Semiring GxB_LOR_EQ_INT16; -extern GrB_Semiring GxB_LOR_EQ_INT32; -extern GrB_Semiring GxB_LOR_EQ_INT64; -extern GrB_Semiring GxB_LOR_EQ_UINT8; -extern GrB_Semiring GxB_LOR_EQ_UINT16; -extern GrB_Semiring GxB_LOR_EQ_UINT32; -extern GrB_Semiring GxB_LOR_EQ_UINT64; -extern GrB_Semiring GxB_LOR_FIRST_BOOL; -extern GrB_Semiring GxB_LOR_GE_BOOL; -extern GrB_Semiring GxB_LOR_GE_FP32; -extern GrB_Semiring GxB_LOR_GE_FP64; -extern GrB_Semiring GxB_LOR_GE_INT8; -extern GrB_Semiring GxB_LOR_GE_INT16; -extern GrB_Semiring GxB_LOR_GE_INT32; -extern GrB_Semiring GxB_LOR_GE_INT64; -extern GrB_Semiring GxB_LOR_GE_UINT8; -extern GrB_Semiring GxB_LOR_GE_UINT16; -extern GrB_Semiring GxB_LOR_GE_UINT32; -extern GrB_Semiring GxB_LOR_GE_UINT64; -extern GrB_Semiring GxB_LOR_GT_BOOL; -extern GrB_Semiring GxB_LOR_GT_FP32; -extern GrB_Semiring GxB_LOR_GT_FP64; -extern GrB_Semiring GxB_LOR_GT_INT8; -extern GrB_Semiring GxB_LOR_GT_INT16; -extern GrB_Semiring GxB_LOR_GT_INT32; -extern GrB_Semiring GxB_LOR_GT_INT64; -extern GrB_Semiring GxB_LOR_GT_UINT8; -extern GrB_Semiring GxB_LOR_GT_UINT16; -extern GrB_Semiring GxB_LOR_GT_UINT32; -extern GrB_Semiring GxB_LOR_GT_UINT64; -extern GrB_Semiring GxB_LOR_LE_BOOL; -extern GrB_Semiring GxB_LOR_LE_FP32; -extern GrB_Semiring GxB_LOR_LE_FP64; -extern GrB_Semiring GxB_LOR_LE_INT8; -extern GrB_Semiring GxB_LOR_LE_INT16; -extern GrB_Semiring GxB_LOR_LE_INT32; -extern GrB_Semiring GxB_LOR_LE_INT64; -extern GrB_Semiring GxB_LOR_LE_UINT8; -extern GrB_Semiring GxB_LOR_LE_UINT16; -extern GrB_Semiring GxB_LOR_LE_UINT32; -extern GrB_Semiring GxB_LOR_LE_UINT64; -extern GrB_Semiring GxB_LOR_LOR_BOOL; -extern GrB_Semiring GxB_LOR_LT_BOOL; -extern GrB_Semiring GxB_LOR_LT_FP32; -extern GrB_Semiring GxB_LOR_LT_FP64; -extern GrB_Semiring GxB_LOR_LT_INT8; -extern GrB_Semiring GxB_LOR_LT_INT16; -extern GrB_Semiring GxB_LOR_LT_INT32; -extern GrB_Semiring GxB_LOR_LT_INT64; -extern GrB_Semiring GxB_LOR_LT_UINT8; -extern GrB_Semiring GxB_LOR_LT_UINT16; -extern GrB_Semiring GxB_LOR_LT_UINT32; -extern GrB_Semiring GxB_LOR_LT_UINT64; -extern GrB_Semiring GxB_LOR_LXOR_BOOL; -extern GrB_Semiring GxB_LOR_NE_FP32; -extern GrB_Semiring GxB_LOR_NE_FP64; -extern GrB_Semiring GxB_LOR_NE_INT8; -extern GrB_Semiring GxB_LOR_NE_INT16; -extern GrB_Semiring GxB_LOR_NE_INT32; -extern GrB_Semiring GxB_LOR_NE_INT64; -extern GrB_Semiring GxB_LOR_NE_UINT8; -extern GrB_Semiring GxB_LOR_NE_UINT16; -extern GrB_Semiring GxB_LOR_NE_UINT32; -extern GrB_Semiring GxB_LOR_NE_UINT64; -extern GrB_Semiring GxB_LOR_PAIR_BOOL; -extern GrB_Semiring GxB_LOR_SECOND_BOOL; -extern GrB_Semiring GxB_LXOR_EQ_BOOL; -extern GrB_Semiring GxB_LXOR_EQ_FP32; -extern GrB_Semiring GxB_LXOR_EQ_FP64; -extern GrB_Semiring GxB_LXOR_EQ_INT8; -extern GrB_Semiring GxB_LXOR_EQ_INT16; -extern GrB_Semiring GxB_LXOR_EQ_INT32; -extern GrB_Semiring GxB_LXOR_EQ_INT64; -extern GrB_Semiring GxB_LXOR_EQ_UINT8; -extern GrB_Semiring GxB_LXOR_EQ_UINT16; -extern GrB_Semiring GxB_LXOR_EQ_UINT32; -extern GrB_Semiring GxB_LXOR_EQ_UINT64; -extern GrB_Semiring GxB_LXOR_FIRST_BOOL; -extern GrB_Semiring GxB_LXOR_GE_BOOL; -extern GrB_Semiring GxB_LXOR_GE_FP32; -extern GrB_Semiring GxB_LXOR_GE_FP64; -extern GrB_Semiring GxB_LXOR_GE_INT8; -extern GrB_Semiring GxB_LXOR_GE_INT16; -extern GrB_Semiring GxB_LXOR_GE_INT32; -extern GrB_Semiring GxB_LXOR_GE_INT64; -extern GrB_Semiring GxB_LXOR_GE_UINT8; -extern GrB_Semiring GxB_LXOR_GE_UINT16; -extern GrB_Semiring GxB_LXOR_GE_UINT32; -extern GrB_Semiring GxB_LXOR_GE_UINT64; -extern GrB_Semiring GxB_LXOR_GT_BOOL; -extern GrB_Semiring GxB_LXOR_GT_FP32; -extern GrB_Semiring GxB_LXOR_GT_FP64; -extern GrB_Semiring GxB_LXOR_GT_INT8; -extern GrB_Semiring GxB_LXOR_GT_INT16; -extern GrB_Semiring GxB_LXOR_GT_INT32; -extern GrB_Semiring GxB_LXOR_GT_INT64; -extern GrB_Semiring GxB_LXOR_GT_UINT8; -extern GrB_Semiring GxB_LXOR_GT_UINT16; -extern GrB_Semiring GxB_LXOR_GT_UINT32; -extern GrB_Semiring GxB_LXOR_GT_UINT64; -extern GrB_Semiring GxB_LXOR_LE_BOOL; -extern GrB_Semiring GxB_LXOR_LE_FP32; -extern GrB_Semiring GxB_LXOR_LE_FP64; -extern GrB_Semiring GxB_LXOR_LE_INT8; -extern GrB_Semiring GxB_LXOR_LE_INT16; -extern GrB_Semiring GxB_LXOR_LE_INT32; -extern GrB_Semiring GxB_LXOR_LE_INT64; -extern GrB_Semiring GxB_LXOR_LE_UINT8; -extern GrB_Semiring GxB_LXOR_LE_UINT16; -extern GrB_Semiring GxB_LXOR_LE_UINT32; -extern GrB_Semiring GxB_LXOR_LE_UINT64; -extern GrB_Semiring GxB_LXOR_LOR_BOOL; -extern GrB_Semiring GxB_LXOR_LT_BOOL; -extern GrB_Semiring GxB_LXOR_LT_FP32; -extern GrB_Semiring GxB_LXOR_LT_FP64; -extern GrB_Semiring GxB_LXOR_LT_INT8; -extern GrB_Semiring GxB_LXOR_LT_INT16; -extern GrB_Semiring GxB_LXOR_LT_INT32; -extern GrB_Semiring GxB_LXOR_LT_INT64; -extern GrB_Semiring GxB_LXOR_LT_UINT8; -extern GrB_Semiring GxB_LXOR_LT_UINT16; -extern GrB_Semiring GxB_LXOR_LT_UINT32; -extern GrB_Semiring GxB_LXOR_LT_UINT64; -extern GrB_Semiring GxB_LXOR_LXOR_BOOL; -extern GrB_Semiring GxB_LXOR_NE_FP32; -extern GrB_Semiring GxB_LXOR_NE_FP64; -extern GrB_Semiring GxB_LXOR_NE_INT8; -extern GrB_Semiring GxB_LXOR_NE_INT16; -extern GrB_Semiring GxB_LXOR_NE_INT32; -extern GrB_Semiring GxB_LXOR_NE_INT64; -extern GrB_Semiring GxB_LXOR_NE_UINT8; -extern GrB_Semiring GxB_LXOR_NE_UINT16; -extern GrB_Semiring GxB_LXOR_NE_UINT32; -extern GrB_Semiring GxB_LXOR_NE_UINT64; -extern GrB_Semiring GxB_LXOR_PAIR_BOOL; -extern GrB_Semiring GxB_LXOR_SECOND_BOOL; -extern GrB_Semiring GxB_MAX_DIV_FP32; -extern GrB_Semiring GxB_MAX_DIV_FP64; -extern GrB_Semiring GxB_MAX_DIV_INT8; -extern GrB_Semiring GxB_MAX_DIV_INT16; -extern GrB_Semiring GxB_MAX_DIV_INT32; -extern GrB_Semiring GxB_MAX_DIV_INT64; -extern GrB_Semiring GxB_MAX_DIV_UINT8; -extern GrB_Semiring GxB_MAX_DIV_UINT16; -extern GrB_Semiring GxB_MAX_DIV_UINT32; -extern GrB_Semiring GxB_MAX_DIV_UINT64; -extern GrB_Semiring GxB_MAX_FIRSTI1_INT32; -extern GrB_Semiring GxB_MAX_FIRSTI1_INT64; -extern GrB_Semiring GxB_MAX_FIRSTI_INT32; -extern GrB_Semiring GxB_MAX_FIRSTI_INT64; -extern GrB_Semiring GxB_MAX_FIRSTJ1_INT32; -extern GrB_Semiring GxB_MAX_FIRSTJ1_INT64; -extern GrB_Semiring GxB_MAX_FIRSTJ_INT32; -extern GrB_Semiring GxB_MAX_FIRSTJ_INT64; -extern GrB_Semiring GxB_MAX_ISEQ_FP32; -extern GrB_Semiring GxB_MAX_ISEQ_FP64; -extern GrB_Semiring GxB_MAX_ISEQ_INT8; -extern GrB_Semiring GxB_MAX_ISEQ_INT16; -extern GrB_Semiring GxB_MAX_ISEQ_INT32; -extern GrB_Semiring GxB_MAX_ISEQ_INT64; -extern GrB_Semiring GxB_MAX_ISEQ_UINT8; -extern GrB_Semiring GxB_MAX_ISEQ_UINT16; -extern GrB_Semiring GxB_MAX_ISEQ_UINT32; -extern GrB_Semiring GxB_MAX_ISEQ_UINT64; -extern GrB_Semiring GxB_MAX_ISGE_FP32; -extern GrB_Semiring GxB_MAX_ISGE_FP64; -extern GrB_Semiring GxB_MAX_ISGE_INT8; -extern GrB_Semiring GxB_MAX_ISGE_INT16; -extern GrB_Semiring GxB_MAX_ISGE_INT32; -extern GrB_Semiring GxB_MAX_ISGE_INT64; -extern GrB_Semiring GxB_MAX_ISGE_UINT8; -extern GrB_Semiring GxB_MAX_ISGE_UINT16; -extern GrB_Semiring GxB_MAX_ISGE_UINT32; -extern GrB_Semiring GxB_MAX_ISGE_UINT64; -extern GrB_Semiring GxB_MAX_ISGT_FP32; -extern GrB_Semiring GxB_MAX_ISGT_FP64; -extern GrB_Semiring GxB_MAX_ISGT_INT8; -extern GrB_Semiring GxB_MAX_ISGT_INT16; -extern GrB_Semiring GxB_MAX_ISGT_INT32; -extern GrB_Semiring GxB_MAX_ISGT_INT64; -extern GrB_Semiring GxB_MAX_ISGT_UINT8; -extern GrB_Semiring GxB_MAX_ISGT_UINT16; -extern GrB_Semiring GxB_MAX_ISGT_UINT32; -extern GrB_Semiring GxB_MAX_ISGT_UINT64; -extern GrB_Semiring GxB_MAX_ISLE_FP32; -extern GrB_Semiring GxB_MAX_ISLE_FP64; -extern GrB_Semiring GxB_MAX_ISLE_INT8; -extern GrB_Semiring GxB_MAX_ISLE_INT16; -extern GrB_Semiring GxB_MAX_ISLE_INT32; -extern GrB_Semiring GxB_MAX_ISLE_INT64; -extern GrB_Semiring GxB_MAX_ISLE_UINT8; -extern GrB_Semiring GxB_MAX_ISLE_UINT16; -extern GrB_Semiring GxB_MAX_ISLE_UINT32; -extern GrB_Semiring GxB_MAX_ISLE_UINT64; -extern GrB_Semiring GxB_MAX_ISLT_FP32; -extern GrB_Semiring GxB_MAX_ISLT_FP64; -extern GrB_Semiring GxB_MAX_ISLT_INT8; -extern GrB_Semiring GxB_MAX_ISLT_INT16; -extern GrB_Semiring GxB_MAX_ISLT_INT32; -extern GrB_Semiring GxB_MAX_ISLT_INT64; -extern GrB_Semiring GxB_MAX_ISLT_UINT8; -extern GrB_Semiring GxB_MAX_ISLT_UINT16; -extern GrB_Semiring GxB_MAX_ISLT_UINT32; -extern GrB_Semiring GxB_MAX_ISLT_UINT64; -extern GrB_Semiring GxB_MAX_ISNE_FP32; -extern GrB_Semiring GxB_MAX_ISNE_FP64; -extern GrB_Semiring GxB_MAX_ISNE_INT8; -extern GrB_Semiring GxB_MAX_ISNE_INT16; -extern GrB_Semiring GxB_MAX_ISNE_INT32; -extern GrB_Semiring GxB_MAX_ISNE_INT64; -extern GrB_Semiring GxB_MAX_ISNE_UINT8; -extern GrB_Semiring GxB_MAX_ISNE_UINT16; -extern GrB_Semiring GxB_MAX_ISNE_UINT32; -extern GrB_Semiring GxB_MAX_ISNE_UINT64; -extern GrB_Semiring GxB_MAX_LAND_FP32; -extern GrB_Semiring GxB_MAX_LAND_FP64; -extern GrB_Semiring GxB_MAX_LAND_INT8; -extern GrB_Semiring GxB_MAX_LAND_INT16; -extern GrB_Semiring GxB_MAX_LAND_INT32; -extern GrB_Semiring GxB_MAX_LAND_INT64; -extern GrB_Semiring GxB_MAX_LAND_UINT8; -extern GrB_Semiring GxB_MAX_LAND_UINT16; -extern GrB_Semiring GxB_MAX_LAND_UINT32; -extern GrB_Semiring GxB_MAX_LAND_UINT64; -extern GrB_Semiring GxB_MAX_LOR_FP32; -extern GrB_Semiring GxB_MAX_LOR_FP64; -extern GrB_Semiring GxB_MAX_LOR_INT8; -extern GrB_Semiring GxB_MAX_LOR_INT16; -extern GrB_Semiring GxB_MAX_LOR_INT32; -extern GrB_Semiring GxB_MAX_LOR_INT64; -extern GrB_Semiring GxB_MAX_LOR_UINT8; -extern GrB_Semiring GxB_MAX_LOR_UINT16; -extern GrB_Semiring GxB_MAX_LOR_UINT32; -extern GrB_Semiring GxB_MAX_LOR_UINT64; -extern GrB_Semiring GxB_MAX_LXOR_FP32; -extern GrB_Semiring GxB_MAX_LXOR_FP64; -extern GrB_Semiring GxB_MAX_LXOR_INT8; -extern GrB_Semiring GxB_MAX_LXOR_INT16; -extern GrB_Semiring GxB_MAX_LXOR_INT32; -extern GrB_Semiring GxB_MAX_LXOR_INT64; -extern GrB_Semiring GxB_MAX_LXOR_UINT8; -extern GrB_Semiring GxB_MAX_LXOR_UINT16; -extern GrB_Semiring GxB_MAX_LXOR_UINT32; -extern GrB_Semiring GxB_MAX_LXOR_UINT64; -extern GrB_Semiring GxB_MAX_MAX_FP32; -extern GrB_Semiring GxB_MAX_MAX_FP64; -extern GrB_Semiring GxB_MAX_MAX_INT8; -extern GrB_Semiring GxB_MAX_MAX_INT16; -extern GrB_Semiring GxB_MAX_MAX_INT32; -extern GrB_Semiring GxB_MAX_MAX_INT64; -extern GrB_Semiring GxB_MAX_MAX_UINT8; -extern GrB_Semiring GxB_MAX_MAX_UINT16; -extern GrB_Semiring GxB_MAX_MAX_UINT32; -extern GrB_Semiring GxB_MAX_MAX_UINT64; -extern GrB_Semiring GxB_MAX_MINUS_FP32; -extern GrB_Semiring GxB_MAX_MINUS_FP64; -extern GrB_Semiring GxB_MAX_MINUS_INT8; -extern GrB_Semiring GxB_MAX_MINUS_INT16; -extern GrB_Semiring GxB_MAX_MINUS_INT32; -extern GrB_Semiring GxB_MAX_MINUS_INT64; -extern GrB_Semiring GxB_MAX_MINUS_UINT8; -extern GrB_Semiring GxB_MAX_MINUS_UINT16; -extern GrB_Semiring GxB_MAX_MINUS_UINT32; -extern GrB_Semiring GxB_MAX_MINUS_UINT64; -extern GrB_Semiring GxB_MAX_PAIR_FP32; -extern GrB_Semiring GxB_MAX_PAIR_FP64; -extern GrB_Semiring GxB_MAX_PAIR_INT8; -extern GrB_Semiring GxB_MAX_PAIR_INT16; -extern GrB_Semiring GxB_MAX_PAIR_INT32; -extern GrB_Semiring GxB_MAX_PAIR_INT64; -extern GrB_Semiring GxB_MAX_PAIR_UINT8; -extern GrB_Semiring GxB_MAX_PAIR_UINT16; -extern GrB_Semiring GxB_MAX_PAIR_UINT32; -extern GrB_Semiring GxB_MAX_PAIR_UINT64; -extern GrB_Semiring GxB_MAX_RDIV_FP32; -extern GrB_Semiring GxB_MAX_RDIV_FP64; -extern GrB_Semiring GxB_MAX_RDIV_INT8; -extern GrB_Semiring GxB_MAX_RDIV_INT16; -extern GrB_Semiring GxB_MAX_RDIV_INT32; -extern GrB_Semiring GxB_MAX_RDIV_INT64; -extern GrB_Semiring GxB_MAX_RDIV_UINT8; -extern GrB_Semiring GxB_MAX_RDIV_UINT16; -extern GrB_Semiring GxB_MAX_RDIV_UINT32; -extern GrB_Semiring GxB_MAX_RDIV_UINT64; -extern GrB_Semiring GxB_MAX_RMINUS_FP32; -extern GrB_Semiring GxB_MAX_RMINUS_FP64; -extern GrB_Semiring GxB_MAX_RMINUS_INT8; -extern GrB_Semiring GxB_MAX_RMINUS_INT16; -extern GrB_Semiring GxB_MAX_RMINUS_INT32; -extern GrB_Semiring GxB_MAX_RMINUS_INT64; -extern GrB_Semiring GxB_MAX_RMINUS_UINT8; -extern GrB_Semiring GxB_MAX_RMINUS_UINT16; -extern GrB_Semiring GxB_MAX_RMINUS_UINT32; -extern GrB_Semiring GxB_MAX_RMINUS_UINT64; -extern GrB_Semiring GxB_MAX_SECONDI1_INT32; -extern GrB_Semiring GxB_MAX_SECONDI1_INT64; -extern GrB_Semiring GxB_MAX_SECONDI_INT32; -extern GrB_Semiring GxB_MAX_SECONDI_INT64; -extern GrB_Semiring GxB_MAX_SECONDJ1_INT32; -extern GrB_Semiring GxB_MAX_SECONDJ1_INT64; -extern GrB_Semiring GxB_MAX_SECONDJ_INT32; -extern GrB_Semiring GxB_MAX_SECONDJ_INT64; -extern GrB_Semiring GxB_MIN_DIV_FP32; -extern GrB_Semiring GxB_MIN_DIV_FP64; -extern GrB_Semiring GxB_MIN_DIV_INT8; -extern GrB_Semiring GxB_MIN_DIV_INT16; -extern GrB_Semiring GxB_MIN_DIV_INT32; -extern GrB_Semiring GxB_MIN_DIV_INT64; -extern GrB_Semiring GxB_MIN_DIV_UINT8; -extern GrB_Semiring GxB_MIN_DIV_UINT16; -extern GrB_Semiring GxB_MIN_DIV_UINT32; -extern GrB_Semiring GxB_MIN_DIV_UINT64; -extern GrB_Semiring GxB_MIN_FIRSTI1_INT32; -extern GrB_Semiring GxB_MIN_FIRSTI1_INT64; -extern GrB_Semiring GxB_MIN_FIRSTI_INT32; -extern GrB_Semiring GxB_MIN_FIRSTI_INT64; -extern GrB_Semiring GxB_MIN_FIRSTJ1_INT32; -extern GrB_Semiring GxB_MIN_FIRSTJ1_INT64; -extern GrB_Semiring GxB_MIN_FIRSTJ_INT32; -extern GrB_Semiring GxB_MIN_FIRSTJ_INT64; -extern GrB_Semiring GxB_MIN_ISEQ_FP32; -extern GrB_Semiring GxB_MIN_ISEQ_FP64; -extern GrB_Semiring GxB_MIN_ISEQ_INT8; -extern GrB_Semiring GxB_MIN_ISEQ_INT16; -extern GrB_Semiring GxB_MIN_ISEQ_INT32; -extern GrB_Semiring GxB_MIN_ISEQ_INT64; -extern GrB_Semiring GxB_MIN_ISEQ_UINT8; -extern GrB_Semiring GxB_MIN_ISEQ_UINT16; -extern GrB_Semiring GxB_MIN_ISEQ_UINT32; -extern GrB_Semiring GxB_MIN_ISEQ_UINT64; -extern GrB_Semiring GxB_MIN_ISGE_FP32; -extern GrB_Semiring GxB_MIN_ISGE_FP64; -extern GrB_Semiring GxB_MIN_ISGE_INT8; -extern GrB_Semiring GxB_MIN_ISGE_INT16; -extern GrB_Semiring GxB_MIN_ISGE_INT32; -extern GrB_Semiring GxB_MIN_ISGE_INT64; -extern GrB_Semiring GxB_MIN_ISGE_UINT8; -extern GrB_Semiring GxB_MIN_ISGE_UINT16; -extern GrB_Semiring GxB_MIN_ISGE_UINT32; -extern GrB_Semiring GxB_MIN_ISGE_UINT64; -extern GrB_Semiring GxB_MIN_ISGT_FP32; -extern GrB_Semiring GxB_MIN_ISGT_FP64; -extern GrB_Semiring GxB_MIN_ISGT_INT8; -extern GrB_Semiring GxB_MIN_ISGT_INT16; -extern GrB_Semiring GxB_MIN_ISGT_INT32; -extern GrB_Semiring GxB_MIN_ISGT_INT64; -extern GrB_Semiring GxB_MIN_ISGT_UINT8; -extern GrB_Semiring GxB_MIN_ISGT_UINT16; -extern GrB_Semiring GxB_MIN_ISGT_UINT32; -extern GrB_Semiring GxB_MIN_ISGT_UINT64; -extern GrB_Semiring GxB_MIN_ISLE_FP32; -extern GrB_Semiring GxB_MIN_ISLE_FP64; -extern GrB_Semiring GxB_MIN_ISLE_INT8; -extern GrB_Semiring GxB_MIN_ISLE_INT16; -extern GrB_Semiring GxB_MIN_ISLE_INT32; -extern GrB_Semiring GxB_MIN_ISLE_INT64; -extern GrB_Semiring GxB_MIN_ISLE_UINT8; -extern GrB_Semiring GxB_MIN_ISLE_UINT16; -extern GrB_Semiring GxB_MIN_ISLE_UINT32; -extern GrB_Semiring GxB_MIN_ISLE_UINT64; -extern GrB_Semiring GxB_MIN_ISLT_FP32; -extern GrB_Semiring GxB_MIN_ISLT_FP64; -extern GrB_Semiring GxB_MIN_ISLT_INT8; -extern GrB_Semiring GxB_MIN_ISLT_INT16; -extern GrB_Semiring GxB_MIN_ISLT_INT32; -extern GrB_Semiring GxB_MIN_ISLT_INT64; -extern GrB_Semiring GxB_MIN_ISLT_UINT8; -extern GrB_Semiring GxB_MIN_ISLT_UINT16; -extern GrB_Semiring GxB_MIN_ISLT_UINT32; -extern GrB_Semiring GxB_MIN_ISLT_UINT64; -extern GrB_Semiring GxB_MIN_ISNE_FP32; -extern GrB_Semiring GxB_MIN_ISNE_FP64; -extern GrB_Semiring GxB_MIN_ISNE_INT8; -extern GrB_Semiring GxB_MIN_ISNE_INT16; -extern GrB_Semiring GxB_MIN_ISNE_INT32; -extern GrB_Semiring GxB_MIN_ISNE_INT64; -extern GrB_Semiring GxB_MIN_ISNE_UINT8; -extern GrB_Semiring GxB_MIN_ISNE_UINT16; -extern GrB_Semiring GxB_MIN_ISNE_UINT32; -extern GrB_Semiring GxB_MIN_ISNE_UINT64; -extern GrB_Semiring GxB_MIN_LAND_FP32; -extern GrB_Semiring GxB_MIN_LAND_FP64; -extern GrB_Semiring GxB_MIN_LAND_INT8; -extern GrB_Semiring GxB_MIN_LAND_INT16; -extern GrB_Semiring GxB_MIN_LAND_INT32; -extern GrB_Semiring GxB_MIN_LAND_INT64; -extern GrB_Semiring GxB_MIN_LAND_UINT8; -extern GrB_Semiring GxB_MIN_LAND_UINT16; -extern GrB_Semiring GxB_MIN_LAND_UINT32; -extern GrB_Semiring GxB_MIN_LAND_UINT64; -extern GrB_Semiring GxB_MIN_LOR_FP32; -extern GrB_Semiring GxB_MIN_LOR_FP64; -extern GrB_Semiring GxB_MIN_LOR_INT8; -extern GrB_Semiring GxB_MIN_LOR_INT16; -extern GrB_Semiring GxB_MIN_LOR_INT32; -extern GrB_Semiring GxB_MIN_LOR_INT64; -extern GrB_Semiring GxB_MIN_LOR_UINT8; -extern GrB_Semiring GxB_MIN_LOR_UINT16; -extern GrB_Semiring GxB_MIN_LOR_UINT32; -extern GrB_Semiring GxB_MIN_LOR_UINT64; -extern GrB_Semiring GxB_MIN_LXOR_FP32; -extern GrB_Semiring GxB_MIN_LXOR_FP64; -extern GrB_Semiring GxB_MIN_LXOR_INT8; -extern GrB_Semiring GxB_MIN_LXOR_INT16; -extern GrB_Semiring GxB_MIN_LXOR_INT32; -extern GrB_Semiring GxB_MIN_LXOR_INT64; -extern GrB_Semiring GxB_MIN_LXOR_UINT8; -extern GrB_Semiring GxB_MIN_LXOR_UINT16; -extern GrB_Semiring GxB_MIN_LXOR_UINT32; -extern GrB_Semiring GxB_MIN_LXOR_UINT64; -extern GrB_Semiring GxB_MIN_MINUS_FP32; -extern GrB_Semiring GxB_MIN_MINUS_FP64; -extern GrB_Semiring GxB_MIN_MINUS_INT8; -extern GrB_Semiring GxB_MIN_MINUS_INT16; -extern GrB_Semiring GxB_MIN_MINUS_INT32; -extern GrB_Semiring GxB_MIN_MINUS_INT64; -extern GrB_Semiring GxB_MIN_MINUS_UINT8; -extern GrB_Semiring GxB_MIN_MINUS_UINT16; -extern GrB_Semiring GxB_MIN_MINUS_UINT32; -extern GrB_Semiring GxB_MIN_MINUS_UINT64; -extern GrB_Semiring GxB_MIN_MIN_FP32; -extern GrB_Semiring GxB_MIN_MIN_FP64; -extern GrB_Semiring GxB_MIN_MIN_INT8; -extern GrB_Semiring GxB_MIN_MIN_INT16; -extern GrB_Semiring GxB_MIN_MIN_INT32; -extern GrB_Semiring GxB_MIN_MIN_INT64; -extern GrB_Semiring GxB_MIN_MIN_UINT8; -extern GrB_Semiring GxB_MIN_MIN_UINT16; -extern GrB_Semiring GxB_MIN_MIN_UINT32; -extern GrB_Semiring GxB_MIN_MIN_UINT64; -extern GrB_Semiring GxB_MIN_PAIR_FP32; -extern GrB_Semiring GxB_MIN_PAIR_FP64; -extern GrB_Semiring GxB_MIN_PAIR_INT8; -extern GrB_Semiring GxB_MIN_PAIR_INT16; -extern GrB_Semiring GxB_MIN_PAIR_INT32; -extern GrB_Semiring GxB_MIN_PAIR_INT64; -extern GrB_Semiring GxB_MIN_PAIR_UINT8; -extern GrB_Semiring GxB_MIN_PAIR_UINT16; -extern GrB_Semiring GxB_MIN_PAIR_UINT32; -extern GrB_Semiring GxB_MIN_PAIR_UINT64; -extern GrB_Semiring GxB_MIN_RDIV_FP32; -extern GrB_Semiring GxB_MIN_RDIV_FP64; -extern GrB_Semiring GxB_MIN_RDIV_INT8; -extern GrB_Semiring GxB_MIN_RDIV_INT16; -extern GrB_Semiring GxB_MIN_RDIV_INT32; -extern GrB_Semiring GxB_MIN_RDIV_INT64; -extern GrB_Semiring GxB_MIN_RDIV_UINT8; -extern GrB_Semiring GxB_MIN_RDIV_UINT16; -extern GrB_Semiring GxB_MIN_RDIV_UINT32; -extern GrB_Semiring GxB_MIN_RDIV_UINT64; -extern GrB_Semiring GxB_MIN_RMINUS_FP32; -extern GrB_Semiring GxB_MIN_RMINUS_FP64; -extern GrB_Semiring GxB_MIN_RMINUS_INT8; -extern GrB_Semiring GxB_MIN_RMINUS_INT16; -extern GrB_Semiring GxB_MIN_RMINUS_INT32; -extern GrB_Semiring GxB_MIN_RMINUS_INT64; -extern GrB_Semiring GxB_MIN_RMINUS_UINT8; -extern GrB_Semiring GxB_MIN_RMINUS_UINT16; -extern GrB_Semiring GxB_MIN_RMINUS_UINT32; -extern GrB_Semiring GxB_MIN_RMINUS_UINT64; -extern GrB_Semiring GxB_MIN_SECONDI1_INT32; -extern GrB_Semiring GxB_MIN_SECONDI1_INT64; -extern GrB_Semiring GxB_MIN_SECONDI_INT32; -extern GrB_Semiring GxB_MIN_SECONDI_INT64; -extern GrB_Semiring GxB_MIN_SECONDJ1_INT32; -extern GrB_Semiring GxB_MIN_SECONDJ1_INT64; -extern GrB_Semiring GxB_MIN_SECONDJ_INT32; -extern GrB_Semiring GxB_MIN_SECONDJ_INT64; -extern GrB_Semiring GxB_PLUS_DIV_FC32; -extern GrB_Semiring GxB_PLUS_DIV_FC64; -extern GrB_Semiring GxB_PLUS_DIV_FP32; -extern GrB_Semiring GxB_PLUS_DIV_FP64; -extern GrB_Semiring GxB_PLUS_DIV_INT8; -extern GrB_Semiring GxB_PLUS_DIV_INT16; -extern GrB_Semiring GxB_PLUS_DIV_INT32; -extern GrB_Semiring GxB_PLUS_DIV_INT64; -extern GrB_Semiring GxB_PLUS_DIV_UINT8; -extern GrB_Semiring GxB_PLUS_DIV_UINT16; -extern GrB_Semiring GxB_PLUS_DIV_UINT32; -extern GrB_Semiring GxB_PLUS_DIV_UINT64; -extern GrB_Semiring GxB_PLUS_FIRSTI1_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTI1_INT64; -extern GrB_Semiring GxB_PLUS_FIRSTI_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTI_INT64; -extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT64; -extern GrB_Semiring GxB_PLUS_FIRSTJ_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTJ_INT64; -extern GrB_Semiring GxB_PLUS_FIRST_FC32; -extern GrB_Semiring GxB_PLUS_FIRST_FC64; -extern GrB_Semiring GxB_PLUS_FIRST_FP32; -extern GrB_Semiring GxB_PLUS_FIRST_FP64; -extern GrB_Semiring GxB_PLUS_FIRST_INT8; -extern GrB_Semiring GxB_PLUS_FIRST_INT16; -extern GrB_Semiring GxB_PLUS_FIRST_INT32; -extern GrB_Semiring GxB_PLUS_FIRST_INT64; -extern GrB_Semiring GxB_PLUS_FIRST_UINT8; -extern GrB_Semiring GxB_PLUS_FIRST_UINT16; -extern GrB_Semiring GxB_PLUS_FIRST_UINT32; -extern GrB_Semiring GxB_PLUS_FIRST_UINT64; -extern GrB_Semiring GxB_PLUS_ISEQ_FP32; -extern GrB_Semiring GxB_PLUS_ISEQ_FP64; -extern GrB_Semiring GxB_PLUS_ISEQ_INT8; -extern GrB_Semiring GxB_PLUS_ISEQ_INT16; -extern GrB_Semiring GxB_PLUS_ISEQ_INT32; -extern GrB_Semiring GxB_PLUS_ISEQ_INT64; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT8; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT16; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT32; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT64; -extern GrB_Semiring GxB_PLUS_ISGE_FP32; -extern GrB_Semiring GxB_PLUS_ISGE_FP64; -extern GrB_Semiring GxB_PLUS_ISGE_INT8; -extern GrB_Semiring GxB_PLUS_ISGE_INT16; -extern GrB_Semiring GxB_PLUS_ISGE_INT32; -extern GrB_Semiring GxB_PLUS_ISGE_INT64; -extern GrB_Semiring GxB_PLUS_ISGE_UINT8; -extern GrB_Semiring GxB_PLUS_ISGE_UINT16; -extern GrB_Semiring GxB_PLUS_ISGE_UINT32; -extern GrB_Semiring GxB_PLUS_ISGE_UINT64; -extern GrB_Semiring GxB_PLUS_ISGT_FP32; -extern GrB_Semiring GxB_PLUS_ISGT_FP64; -extern GrB_Semiring GxB_PLUS_ISGT_INT8; -extern GrB_Semiring GxB_PLUS_ISGT_INT16; -extern GrB_Semiring GxB_PLUS_ISGT_INT32; -extern GrB_Semiring GxB_PLUS_ISGT_INT64; -extern GrB_Semiring GxB_PLUS_ISGT_UINT8; -extern GrB_Semiring GxB_PLUS_ISGT_UINT16; -extern GrB_Semiring GxB_PLUS_ISGT_UINT32; -extern GrB_Semiring GxB_PLUS_ISGT_UINT64; -extern GrB_Semiring GxB_PLUS_ISLE_FP32; -extern GrB_Semiring GxB_PLUS_ISLE_FP64; -extern GrB_Semiring GxB_PLUS_ISLE_INT8; -extern GrB_Semiring GxB_PLUS_ISLE_INT16; -extern GrB_Semiring GxB_PLUS_ISLE_INT32; -extern GrB_Semiring GxB_PLUS_ISLE_INT64; -extern GrB_Semiring GxB_PLUS_ISLE_UINT8; -extern GrB_Semiring GxB_PLUS_ISLE_UINT16; -extern GrB_Semiring GxB_PLUS_ISLE_UINT32; -extern GrB_Semiring GxB_PLUS_ISLE_UINT64; -extern GrB_Semiring GxB_PLUS_ISLT_FP32; -extern GrB_Semiring GxB_PLUS_ISLT_FP64; -extern GrB_Semiring GxB_PLUS_ISLT_INT8; -extern GrB_Semiring GxB_PLUS_ISLT_INT16; -extern GrB_Semiring GxB_PLUS_ISLT_INT32; -extern GrB_Semiring GxB_PLUS_ISLT_INT64; -extern GrB_Semiring GxB_PLUS_ISLT_UINT8; -extern GrB_Semiring GxB_PLUS_ISLT_UINT16; -extern GrB_Semiring GxB_PLUS_ISLT_UINT32; -extern GrB_Semiring GxB_PLUS_ISLT_UINT64; -extern GrB_Semiring GxB_PLUS_ISNE_FP32; -extern GrB_Semiring GxB_PLUS_ISNE_FP64; -extern GrB_Semiring GxB_PLUS_ISNE_INT8; -extern GrB_Semiring GxB_PLUS_ISNE_INT16; -extern GrB_Semiring GxB_PLUS_ISNE_INT32; -extern GrB_Semiring GxB_PLUS_ISNE_INT64; -extern GrB_Semiring GxB_PLUS_ISNE_UINT8; -extern GrB_Semiring GxB_PLUS_ISNE_UINT16; -extern GrB_Semiring GxB_PLUS_ISNE_UINT32; -extern GrB_Semiring GxB_PLUS_ISNE_UINT64; -extern GrB_Semiring GxB_PLUS_LAND_FP32; -extern GrB_Semiring GxB_PLUS_LAND_FP64; -extern GrB_Semiring GxB_PLUS_LAND_INT8; -extern GrB_Semiring GxB_PLUS_LAND_INT16; -extern GrB_Semiring GxB_PLUS_LAND_INT32; -extern GrB_Semiring GxB_PLUS_LAND_INT64; -extern GrB_Semiring GxB_PLUS_LAND_UINT8; -extern GrB_Semiring GxB_PLUS_LAND_UINT16; -extern GrB_Semiring GxB_PLUS_LAND_UINT32; -extern GrB_Semiring GxB_PLUS_LAND_UINT64; -extern GrB_Semiring GxB_PLUS_LOR_FP32; -extern GrB_Semiring GxB_PLUS_LOR_FP64; -extern GrB_Semiring GxB_PLUS_LOR_INT8; -extern GrB_Semiring GxB_PLUS_LOR_INT16; -extern GrB_Semiring GxB_PLUS_LOR_INT32; -extern GrB_Semiring GxB_PLUS_LOR_INT64; -extern GrB_Semiring GxB_PLUS_LOR_UINT8; -extern GrB_Semiring GxB_PLUS_LOR_UINT16; -extern GrB_Semiring GxB_PLUS_LOR_UINT32; -extern GrB_Semiring GxB_PLUS_LOR_UINT64; -extern GrB_Semiring GxB_PLUS_LXOR_FP32; -extern GrB_Semiring GxB_PLUS_LXOR_FP64; -extern GrB_Semiring GxB_PLUS_LXOR_INT8; -extern GrB_Semiring GxB_PLUS_LXOR_INT16; -extern GrB_Semiring GxB_PLUS_LXOR_INT32; -extern GrB_Semiring GxB_PLUS_LXOR_INT64; -extern GrB_Semiring GxB_PLUS_LXOR_UINT8; -extern GrB_Semiring GxB_PLUS_LXOR_UINT16; -extern GrB_Semiring GxB_PLUS_LXOR_UINT32; -extern GrB_Semiring GxB_PLUS_LXOR_UINT64; -extern GrB_Semiring GxB_PLUS_MAX_FP32; -extern GrB_Semiring GxB_PLUS_MAX_FP64; -extern GrB_Semiring GxB_PLUS_MAX_INT8; -extern GrB_Semiring GxB_PLUS_MAX_INT16; -extern GrB_Semiring GxB_PLUS_MAX_INT32; -extern GrB_Semiring GxB_PLUS_MAX_INT64; -extern GrB_Semiring GxB_PLUS_MAX_UINT8; -extern GrB_Semiring GxB_PLUS_MAX_UINT16; -extern GrB_Semiring GxB_PLUS_MAX_UINT32; -extern GrB_Semiring GxB_PLUS_MAX_UINT64; -extern GrB_Semiring GxB_PLUS_MINUS_FC32; -extern GrB_Semiring GxB_PLUS_MINUS_FC64; -extern GrB_Semiring GxB_PLUS_MINUS_FP32; -extern GrB_Semiring GxB_PLUS_MINUS_FP64; -extern GrB_Semiring GxB_PLUS_MINUS_INT8; -extern GrB_Semiring GxB_PLUS_MINUS_INT16; -extern GrB_Semiring GxB_PLUS_MINUS_INT32; -extern GrB_Semiring GxB_PLUS_MINUS_INT64; -extern GrB_Semiring GxB_PLUS_MINUS_UINT8; -extern GrB_Semiring GxB_PLUS_MINUS_UINT16; -extern GrB_Semiring GxB_PLUS_MINUS_UINT32; -extern GrB_Semiring GxB_PLUS_MINUS_UINT64; -extern GrB_Semiring GxB_PLUS_PAIR_FC32; -extern GrB_Semiring GxB_PLUS_PAIR_FC64; -extern GrB_Semiring GxB_PLUS_PAIR_FP32; -extern GrB_Semiring GxB_PLUS_PAIR_FP64; -extern GrB_Semiring GxB_PLUS_PAIR_INT8; -extern GrB_Semiring GxB_PLUS_PAIR_INT16; -extern GrB_Semiring GxB_PLUS_PAIR_INT32; -extern GrB_Semiring GxB_PLUS_PAIR_INT64; -extern GrB_Semiring GxB_PLUS_PAIR_UINT8; -extern GrB_Semiring GxB_PLUS_PAIR_UINT16; -extern GrB_Semiring GxB_PLUS_PAIR_UINT32; -extern GrB_Semiring GxB_PLUS_PAIR_UINT64; -extern GrB_Semiring GxB_PLUS_PLUS_FC32; -extern GrB_Semiring GxB_PLUS_PLUS_FC64; -extern GrB_Semiring GxB_PLUS_PLUS_FP32; -extern GrB_Semiring GxB_PLUS_PLUS_FP64; -extern GrB_Semiring GxB_PLUS_PLUS_INT8; -extern GrB_Semiring GxB_PLUS_PLUS_INT16; -extern GrB_Semiring GxB_PLUS_PLUS_INT32; -extern GrB_Semiring GxB_PLUS_PLUS_INT64; -extern GrB_Semiring GxB_PLUS_PLUS_UINT8; -extern GrB_Semiring GxB_PLUS_PLUS_UINT16; -extern GrB_Semiring GxB_PLUS_PLUS_UINT32; -extern GrB_Semiring GxB_PLUS_PLUS_UINT64; -extern GrB_Semiring GxB_PLUS_RDIV_FC32; -extern GrB_Semiring GxB_PLUS_RDIV_FC64; -extern GrB_Semiring GxB_PLUS_RDIV_FP32; -extern GrB_Semiring GxB_PLUS_RDIV_FP64; -extern GrB_Semiring GxB_PLUS_RDIV_INT8; -extern GrB_Semiring GxB_PLUS_RDIV_INT16; -extern GrB_Semiring GxB_PLUS_RDIV_INT32; -extern GrB_Semiring GxB_PLUS_RDIV_INT64; -extern GrB_Semiring GxB_PLUS_RDIV_UINT8; -extern GrB_Semiring GxB_PLUS_RDIV_UINT16; -extern GrB_Semiring GxB_PLUS_RDIV_UINT32; -extern GrB_Semiring GxB_PLUS_RDIV_UINT64; -extern GrB_Semiring GxB_PLUS_RMINUS_FC32; -extern GrB_Semiring GxB_PLUS_RMINUS_FC64; -extern GrB_Semiring GxB_PLUS_RMINUS_FP32; -extern GrB_Semiring GxB_PLUS_RMINUS_FP64; -extern GrB_Semiring GxB_PLUS_RMINUS_INT8; -extern GrB_Semiring GxB_PLUS_RMINUS_INT16; -extern GrB_Semiring GxB_PLUS_RMINUS_INT32; -extern GrB_Semiring GxB_PLUS_RMINUS_INT64; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT8; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT16; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT32; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT64; -extern GrB_Semiring GxB_PLUS_SECONDI1_INT32; -extern GrB_Semiring GxB_PLUS_SECONDI1_INT64; -extern GrB_Semiring GxB_PLUS_SECONDI_INT32; -extern GrB_Semiring GxB_PLUS_SECONDI_INT64; -extern GrB_Semiring GxB_PLUS_SECONDJ1_INT32; -extern GrB_Semiring GxB_PLUS_SECONDJ1_INT64; -extern GrB_Semiring GxB_PLUS_SECONDJ_INT32; -extern GrB_Semiring GxB_PLUS_SECONDJ_INT64; -extern GrB_Semiring GxB_PLUS_SECOND_FC32; -extern GrB_Semiring GxB_PLUS_SECOND_FC64; -extern GrB_Semiring GxB_PLUS_SECOND_FP32; -extern GrB_Semiring GxB_PLUS_SECOND_FP64; -extern GrB_Semiring GxB_PLUS_SECOND_INT8; -extern GrB_Semiring GxB_PLUS_SECOND_INT16; -extern GrB_Semiring GxB_PLUS_SECOND_INT32; -extern GrB_Semiring GxB_PLUS_SECOND_INT64; -extern GrB_Semiring GxB_PLUS_SECOND_UINT8; -extern GrB_Semiring GxB_PLUS_SECOND_UINT16; -extern GrB_Semiring GxB_PLUS_SECOND_UINT32; -extern GrB_Semiring GxB_PLUS_SECOND_UINT64; -extern GrB_Semiring GxB_PLUS_TIMES_FC32; -extern GrB_Semiring GxB_PLUS_TIMES_FC64; -extern GrB_Semiring GxB_TIMES_DIV_FC32; -extern GrB_Semiring GxB_TIMES_DIV_FC64; -extern GrB_Semiring GxB_TIMES_DIV_FP32; -extern GrB_Semiring GxB_TIMES_DIV_FP64; -extern GrB_Semiring GxB_TIMES_DIV_INT8; -extern GrB_Semiring GxB_TIMES_DIV_INT16; -extern GrB_Semiring GxB_TIMES_DIV_INT32; -extern GrB_Semiring GxB_TIMES_DIV_INT64; -extern GrB_Semiring GxB_TIMES_DIV_UINT8; -extern GrB_Semiring GxB_TIMES_DIV_UINT16; -extern GrB_Semiring GxB_TIMES_DIV_UINT32; -extern GrB_Semiring GxB_TIMES_DIV_UINT64; -extern GrB_Semiring GxB_TIMES_FIRSTI1_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTI1_INT64; -extern GrB_Semiring GxB_TIMES_FIRSTI_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTI_INT64; -extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT64; -extern GrB_Semiring GxB_TIMES_FIRSTJ_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTJ_INT64; -extern GrB_Semiring GxB_TIMES_FIRST_FC32; -extern GrB_Semiring GxB_TIMES_FIRST_FC64; -extern GrB_Semiring GxB_TIMES_FIRST_FP32; -extern GrB_Semiring GxB_TIMES_FIRST_FP64; -extern GrB_Semiring GxB_TIMES_FIRST_INT8; -extern GrB_Semiring GxB_TIMES_FIRST_INT16; -extern GrB_Semiring GxB_TIMES_FIRST_INT32; -extern GrB_Semiring GxB_TIMES_FIRST_INT64; -extern GrB_Semiring GxB_TIMES_FIRST_UINT8; -extern GrB_Semiring GxB_TIMES_FIRST_UINT16; -extern GrB_Semiring GxB_TIMES_FIRST_UINT32; -extern GrB_Semiring GxB_TIMES_FIRST_UINT64; -extern GrB_Semiring GxB_TIMES_ISEQ_FP32; -extern GrB_Semiring GxB_TIMES_ISEQ_FP64; -extern GrB_Semiring GxB_TIMES_ISEQ_INT8; -extern GrB_Semiring GxB_TIMES_ISEQ_INT16; -extern GrB_Semiring GxB_TIMES_ISEQ_INT32; -extern GrB_Semiring GxB_TIMES_ISEQ_INT64; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT8; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT16; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT32; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT64; -extern GrB_Semiring GxB_TIMES_ISGE_FP32; -extern GrB_Semiring GxB_TIMES_ISGE_FP64; -extern GrB_Semiring GxB_TIMES_ISGE_INT8; -extern GrB_Semiring GxB_TIMES_ISGE_INT16; -extern GrB_Semiring GxB_TIMES_ISGE_INT32; -extern GrB_Semiring GxB_TIMES_ISGE_INT64; -extern GrB_Semiring GxB_TIMES_ISGE_UINT8; -extern GrB_Semiring GxB_TIMES_ISGE_UINT16; -extern GrB_Semiring GxB_TIMES_ISGE_UINT32; -extern GrB_Semiring GxB_TIMES_ISGE_UINT64; -extern GrB_Semiring GxB_TIMES_ISGT_FP32; -extern GrB_Semiring GxB_TIMES_ISGT_FP64; -extern GrB_Semiring GxB_TIMES_ISGT_INT8; -extern GrB_Semiring GxB_TIMES_ISGT_INT16; -extern GrB_Semiring GxB_TIMES_ISGT_INT32; -extern GrB_Semiring GxB_TIMES_ISGT_INT64; -extern GrB_Semiring GxB_TIMES_ISGT_UINT8; -extern GrB_Semiring GxB_TIMES_ISGT_UINT16; -extern GrB_Semiring GxB_TIMES_ISGT_UINT32; -extern GrB_Semiring GxB_TIMES_ISGT_UINT64; -extern GrB_Semiring GxB_TIMES_ISLE_FP32; -extern GrB_Semiring GxB_TIMES_ISLE_FP64; -extern GrB_Semiring GxB_TIMES_ISLE_INT8; -extern GrB_Semiring GxB_TIMES_ISLE_INT16; -extern GrB_Semiring GxB_TIMES_ISLE_INT32; -extern GrB_Semiring GxB_TIMES_ISLE_INT64; -extern GrB_Semiring GxB_TIMES_ISLE_UINT8; -extern GrB_Semiring GxB_TIMES_ISLE_UINT16; -extern GrB_Semiring GxB_TIMES_ISLE_UINT32; -extern GrB_Semiring GxB_TIMES_ISLE_UINT64; -extern GrB_Semiring GxB_TIMES_ISLT_FP32; -extern GrB_Semiring GxB_TIMES_ISLT_FP64; -extern GrB_Semiring GxB_TIMES_ISLT_INT8; -extern GrB_Semiring GxB_TIMES_ISLT_INT16; -extern GrB_Semiring GxB_TIMES_ISLT_INT32; -extern GrB_Semiring GxB_TIMES_ISLT_INT64; -extern GrB_Semiring GxB_TIMES_ISLT_UINT8; -extern GrB_Semiring GxB_TIMES_ISLT_UINT16; -extern GrB_Semiring GxB_TIMES_ISLT_UINT32; -extern GrB_Semiring GxB_TIMES_ISLT_UINT64; -extern GrB_Semiring GxB_TIMES_ISNE_FP32; -extern GrB_Semiring GxB_TIMES_ISNE_FP64; -extern GrB_Semiring GxB_TIMES_ISNE_INT8; -extern GrB_Semiring GxB_TIMES_ISNE_INT16; -extern GrB_Semiring GxB_TIMES_ISNE_INT32; -extern GrB_Semiring GxB_TIMES_ISNE_INT64; -extern GrB_Semiring GxB_TIMES_ISNE_UINT8; -extern GrB_Semiring GxB_TIMES_ISNE_UINT16; -extern GrB_Semiring GxB_TIMES_ISNE_UINT32; -extern GrB_Semiring GxB_TIMES_ISNE_UINT64; -extern GrB_Semiring GxB_TIMES_LAND_FP32; -extern GrB_Semiring GxB_TIMES_LAND_FP64; -extern GrB_Semiring GxB_TIMES_LAND_INT8; -extern GrB_Semiring GxB_TIMES_LAND_INT16; -extern GrB_Semiring GxB_TIMES_LAND_INT32; -extern GrB_Semiring GxB_TIMES_LAND_INT64; -extern GrB_Semiring GxB_TIMES_LAND_UINT8; -extern GrB_Semiring GxB_TIMES_LAND_UINT16; -extern GrB_Semiring GxB_TIMES_LAND_UINT32; -extern GrB_Semiring GxB_TIMES_LAND_UINT64; -extern GrB_Semiring GxB_TIMES_LOR_FP32; -extern GrB_Semiring GxB_TIMES_LOR_FP64; -extern GrB_Semiring GxB_TIMES_LOR_INT8; -extern GrB_Semiring GxB_TIMES_LOR_INT16; -extern GrB_Semiring GxB_TIMES_LOR_INT32; -extern GrB_Semiring GxB_TIMES_LOR_INT64; -extern GrB_Semiring GxB_TIMES_LOR_UINT8; -extern GrB_Semiring GxB_TIMES_LOR_UINT16; -extern GrB_Semiring GxB_TIMES_LOR_UINT32; -extern GrB_Semiring GxB_TIMES_LOR_UINT64; -extern GrB_Semiring GxB_TIMES_LXOR_FP32; -extern GrB_Semiring GxB_TIMES_LXOR_FP64; -extern GrB_Semiring GxB_TIMES_LXOR_INT8; -extern GrB_Semiring GxB_TIMES_LXOR_INT16; -extern GrB_Semiring GxB_TIMES_LXOR_INT32; -extern GrB_Semiring GxB_TIMES_LXOR_INT64; -extern GrB_Semiring GxB_TIMES_LXOR_UINT8; -extern GrB_Semiring GxB_TIMES_LXOR_UINT16; -extern GrB_Semiring GxB_TIMES_LXOR_UINT32; -extern GrB_Semiring GxB_TIMES_LXOR_UINT64; -extern GrB_Semiring GxB_TIMES_MAX_FP32; -extern GrB_Semiring GxB_TIMES_MAX_FP64; -extern GrB_Semiring GxB_TIMES_MAX_INT8; -extern GrB_Semiring GxB_TIMES_MAX_INT16; -extern GrB_Semiring GxB_TIMES_MAX_INT32; -extern GrB_Semiring GxB_TIMES_MAX_INT64; -extern GrB_Semiring GxB_TIMES_MAX_UINT8; -extern GrB_Semiring GxB_TIMES_MAX_UINT16; -extern GrB_Semiring GxB_TIMES_MAX_UINT32; -extern GrB_Semiring GxB_TIMES_MAX_UINT64; -extern GrB_Semiring GxB_TIMES_MINUS_FC32; -extern GrB_Semiring GxB_TIMES_MINUS_FC64; -extern GrB_Semiring GxB_TIMES_MINUS_FP32; -extern GrB_Semiring GxB_TIMES_MINUS_FP64; -extern GrB_Semiring GxB_TIMES_MINUS_INT8; -extern GrB_Semiring GxB_TIMES_MINUS_INT16; -extern GrB_Semiring GxB_TIMES_MINUS_INT32; -extern GrB_Semiring GxB_TIMES_MINUS_INT64; -extern GrB_Semiring GxB_TIMES_MINUS_UINT8; -extern GrB_Semiring GxB_TIMES_MINUS_UINT16; -extern GrB_Semiring GxB_TIMES_MINUS_UINT32; -extern GrB_Semiring GxB_TIMES_MINUS_UINT64; -extern GrB_Semiring GxB_TIMES_MIN_FP32; -extern GrB_Semiring GxB_TIMES_MIN_FP64; -extern GrB_Semiring GxB_TIMES_MIN_INT8; -extern GrB_Semiring GxB_TIMES_MIN_INT16; -extern GrB_Semiring GxB_TIMES_MIN_INT32; -extern GrB_Semiring GxB_TIMES_MIN_INT64; -extern GrB_Semiring GxB_TIMES_MIN_UINT8; -extern GrB_Semiring GxB_TIMES_MIN_UINT16; -extern GrB_Semiring GxB_TIMES_MIN_UINT32; -extern GrB_Semiring GxB_TIMES_MIN_UINT64; -extern GrB_Semiring GxB_TIMES_PAIR_FC32; -extern GrB_Semiring GxB_TIMES_PAIR_FC64; -extern GrB_Semiring GxB_TIMES_PAIR_FP32; -extern GrB_Semiring GxB_TIMES_PAIR_FP64; -extern GrB_Semiring GxB_TIMES_PAIR_INT8; -extern GrB_Semiring GxB_TIMES_PAIR_INT16; -extern GrB_Semiring GxB_TIMES_PAIR_INT32; -extern GrB_Semiring GxB_TIMES_PAIR_INT64; -extern GrB_Semiring GxB_TIMES_PAIR_UINT8; -extern GrB_Semiring GxB_TIMES_PAIR_UINT16; -extern GrB_Semiring GxB_TIMES_PAIR_UINT32; -extern GrB_Semiring GxB_TIMES_PAIR_UINT64; -extern GrB_Semiring GxB_TIMES_PLUS_FC32; -extern GrB_Semiring GxB_TIMES_PLUS_FC64; -extern GrB_Semiring GxB_TIMES_PLUS_FP32; -extern GrB_Semiring GxB_TIMES_PLUS_FP64; -extern GrB_Semiring GxB_TIMES_PLUS_INT8; -extern GrB_Semiring GxB_TIMES_PLUS_INT16; -extern GrB_Semiring GxB_TIMES_PLUS_INT32; -extern GrB_Semiring GxB_TIMES_PLUS_INT64; -extern GrB_Semiring GxB_TIMES_PLUS_UINT8; -extern GrB_Semiring GxB_TIMES_PLUS_UINT16; -extern GrB_Semiring GxB_TIMES_PLUS_UINT32; -extern GrB_Semiring GxB_TIMES_PLUS_UINT64; -extern GrB_Semiring GxB_TIMES_RDIV_FC32; -extern GrB_Semiring GxB_TIMES_RDIV_FC64; -extern GrB_Semiring GxB_TIMES_RDIV_FP32; -extern GrB_Semiring GxB_TIMES_RDIV_FP64; -extern GrB_Semiring GxB_TIMES_RDIV_INT8; -extern GrB_Semiring GxB_TIMES_RDIV_INT16; -extern GrB_Semiring GxB_TIMES_RDIV_INT32; -extern GrB_Semiring GxB_TIMES_RDIV_INT64; -extern GrB_Semiring GxB_TIMES_RDIV_UINT8; -extern GrB_Semiring GxB_TIMES_RDIV_UINT16; -extern GrB_Semiring GxB_TIMES_RDIV_UINT32; -extern GrB_Semiring GxB_TIMES_RDIV_UINT64; -extern GrB_Semiring GxB_TIMES_RMINUS_FC32; -extern GrB_Semiring GxB_TIMES_RMINUS_FC64; -extern GrB_Semiring GxB_TIMES_RMINUS_FP32; -extern GrB_Semiring GxB_TIMES_RMINUS_FP64; -extern GrB_Semiring GxB_TIMES_RMINUS_INT8; -extern GrB_Semiring GxB_TIMES_RMINUS_INT16; -extern GrB_Semiring GxB_TIMES_RMINUS_INT32; -extern GrB_Semiring GxB_TIMES_RMINUS_INT64; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT8; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT16; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT32; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT64; -extern GrB_Semiring GxB_TIMES_SECONDI1_INT32; -extern GrB_Semiring GxB_TIMES_SECONDI1_INT64; -extern GrB_Semiring GxB_TIMES_SECONDI_INT32; -extern GrB_Semiring GxB_TIMES_SECONDI_INT64; -extern GrB_Semiring GxB_TIMES_SECONDJ1_INT32; -extern GrB_Semiring GxB_TIMES_SECONDJ1_INT64; -extern GrB_Semiring GxB_TIMES_SECONDJ_INT32; -extern GrB_Semiring GxB_TIMES_SECONDJ_INT64; -extern GrB_Semiring GxB_TIMES_SECOND_FC32; -extern GrB_Semiring GxB_TIMES_SECOND_FC64; -extern GrB_Semiring GxB_TIMES_SECOND_FP32; -extern GrB_Semiring GxB_TIMES_SECOND_FP64; -extern GrB_Semiring GxB_TIMES_SECOND_INT8; -extern GrB_Semiring GxB_TIMES_SECOND_INT16; -extern GrB_Semiring GxB_TIMES_SECOND_INT32; -extern GrB_Semiring GxB_TIMES_SECOND_INT64; -extern GrB_Semiring GxB_TIMES_SECOND_UINT8; -extern GrB_Semiring GxB_TIMES_SECOND_UINT16; -extern GrB_Semiring GxB_TIMES_SECOND_UINT32; -extern GrB_Semiring GxB_TIMES_SECOND_UINT64; -extern GrB_Semiring GxB_TIMES_TIMES_FC32; -extern GrB_Semiring GxB_TIMES_TIMES_FC64; -extern GrB_Semiring GxB_TIMES_TIMES_FP32; -extern GrB_Semiring GxB_TIMES_TIMES_FP64; -extern GrB_Semiring GxB_TIMES_TIMES_INT8; -extern GrB_Semiring GxB_TIMES_TIMES_INT16; -extern GrB_Semiring GxB_TIMES_TIMES_INT32; -extern GrB_Semiring GxB_TIMES_TIMES_INT64; -extern GrB_Semiring GxB_TIMES_TIMES_UINT8; -extern GrB_Semiring GxB_TIMES_TIMES_UINT16; -extern GrB_Semiring GxB_TIMES_TIMES_UINT32; -extern GrB_Semiring GxB_TIMES_TIMES_UINT64; -extern GrB_Type GxB_FC32; -extern GrB_Type GxB_FC64; -extern GrB_UnaryOp GxB_ABS_FC32; -extern GrB_UnaryOp GxB_ABS_FC64; -extern GrB_UnaryOp GxB_ACOSH_FC32; -extern GrB_UnaryOp GxB_ACOSH_FC64; -extern GrB_UnaryOp GxB_ACOSH_FP32; -extern GrB_UnaryOp GxB_ACOSH_FP64; -extern GrB_UnaryOp GxB_ACOS_FC32; -extern GrB_UnaryOp GxB_ACOS_FC64; -extern GrB_UnaryOp GxB_ACOS_FP32; -extern GrB_UnaryOp GxB_ACOS_FP64; -extern GrB_UnaryOp GxB_AINV_FC32; -extern GrB_UnaryOp GxB_AINV_FC64; -extern GrB_UnaryOp GxB_ASINH_FC32; -extern GrB_UnaryOp GxB_ASINH_FC64; -extern GrB_UnaryOp GxB_ASINH_FP32; -extern GrB_UnaryOp GxB_ASINH_FP64; -extern GrB_UnaryOp GxB_ASIN_FC32; -extern GrB_UnaryOp GxB_ASIN_FC64; -extern GrB_UnaryOp GxB_ASIN_FP32; -extern GrB_UnaryOp GxB_ASIN_FP64; -extern GrB_UnaryOp GxB_ATANH_FC32; -extern GrB_UnaryOp GxB_ATANH_FC64; -extern GrB_UnaryOp GxB_ATANH_FP32; -extern GrB_UnaryOp GxB_ATANH_FP64; -extern GrB_UnaryOp GxB_ATAN_FC32; -extern GrB_UnaryOp GxB_ATAN_FC64; -extern GrB_UnaryOp GxB_ATAN_FP32; -extern GrB_UnaryOp GxB_ATAN_FP64; -extern GrB_UnaryOp GxB_CARG_FC32; -extern GrB_UnaryOp GxB_CARG_FC64; -extern GrB_UnaryOp GxB_CEIL_FC32; -extern GrB_UnaryOp GxB_CEIL_FC64; -extern GrB_UnaryOp GxB_CEIL_FP32; -extern GrB_UnaryOp GxB_CEIL_FP64; -extern GrB_UnaryOp GxB_CIMAG_FC32; -extern GrB_UnaryOp GxB_CIMAG_FC64; -extern GrB_UnaryOp GxB_CONJ_FC32; -extern GrB_UnaryOp GxB_CONJ_FC64; -extern GrB_UnaryOp GxB_COSH_FC32; -extern GrB_UnaryOp GxB_COSH_FC64; -extern GrB_UnaryOp GxB_COSH_FP32; -extern GrB_UnaryOp GxB_COSH_FP64; -extern GrB_UnaryOp GxB_COS_FC32; -extern GrB_UnaryOp GxB_COS_FC64; -extern GrB_UnaryOp GxB_COS_FP32; -extern GrB_UnaryOp GxB_COS_FP64; -extern GrB_UnaryOp GxB_CREAL_FC32; -extern GrB_UnaryOp GxB_CREAL_FC64; -extern GrB_UnaryOp GxB_ERFC_FP32; -extern GrB_UnaryOp GxB_ERFC_FP64; -extern GrB_UnaryOp GxB_ERF_FP32; -extern GrB_UnaryOp GxB_ERF_FP64; -extern GrB_UnaryOp GxB_EXP2_FC32; -extern GrB_UnaryOp GxB_EXP2_FC64; -extern GrB_UnaryOp GxB_EXP2_FP32; -extern GrB_UnaryOp GxB_EXP2_FP64; -extern GrB_UnaryOp GxB_EXPM1_FC32; -extern GrB_UnaryOp GxB_EXPM1_FC64; -extern GrB_UnaryOp GxB_EXPM1_FP32; -extern GrB_UnaryOp GxB_EXPM1_FP64; -extern GrB_UnaryOp GxB_EXP_FC32; -extern GrB_UnaryOp GxB_EXP_FC64; -extern GrB_UnaryOp GxB_EXP_FP32; -extern GrB_UnaryOp GxB_EXP_FP64; -extern GrB_UnaryOp GxB_FLOOR_FC32; -extern GrB_UnaryOp GxB_FLOOR_FC64; -extern GrB_UnaryOp GxB_FLOOR_FP32; -extern GrB_UnaryOp GxB_FLOOR_FP64; -extern GrB_UnaryOp GxB_FREXPE_FP32; -extern GrB_UnaryOp GxB_FREXPE_FP64; -extern GrB_UnaryOp GxB_FREXPX_FP32; -extern GrB_UnaryOp GxB_FREXPX_FP64; -extern GrB_UnaryOp GxB_IDENTITY_FC32; -extern GrB_UnaryOp GxB_IDENTITY_FC64; -extern GrB_UnaryOp GxB_ISFINITE_FC32; -extern GrB_UnaryOp GxB_ISFINITE_FC64; -extern GrB_UnaryOp GxB_ISFINITE_FP32; -extern GrB_UnaryOp GxB_ISFINITE_FP64; -extern GrB_UnaryOp GxB_ISINF_FC32; -extern GrB_UnaryOp GxB_ISINF_FC64; -extern GrB_UnaryOp GxB_ISINF_FP32; -extern GrB_UnaryOp GxB_ISINF_FP64; -extern GrB_UnaryOp GxB_ISNAN_FC32; -extern GrB_UnaryOp GxB_ISNAN_FC64; -extern GrB_UnaryOp GxB_ISNAN_FP32; -extern GrB_UnaryOp GxB_ISNAN_FP64; -extern GrB_UnaryOp GxB_LGAMMA_FP32; -extern GrB_UnaryOp GxB_LGAMMA_FP64; -extern GrB_UnaryOp GxB_LNOT_BOOL; -extern GrB_UnaryOp GxB_LNOT_FP32; -extern GrB_UnaryOp GxB_LNOT_FP64; -extern GrB_UnaryOp GxB_LNOT_INT8; -extern GrB_UnaryOp GxB_LNOT_INT16; -extern GrB_UnaryOp GxB_LNOT_INT32; -extern GrB_UnaryOp GxB_LNOT_INT64; -extern GrB_UnaryOp GxB_LNOT_UINT8; -extern GrB_UnaryOp GxB_LNOT_UINT16; -extern GrB_UnaryOp GxB_LNOT_UINT32; -extern GrB_UnaryOp GxB_LNOT_UINT64; -extern GrB_UnaryOp GxB_LOG10_FC32; -extern GrB_UnaryOp GxB_LOG10_FC64; -extern GrB_UnaryOp GxB_LOG10_FP32; -extern GrB_UnaryOp GxB_LOG10_FP64; -extern GrB_UnaryOp GxB_LOG1P_FC32; -extern GrB_UnaryOp GxB_LOG1P_FC64; -extern GrB_UnaryOp GxB_LOG1P_FP32; -extern GrB_UnaryOp GxB_LOG1P_FP64; -extern GrB_UnaryOp GxB_LOG2_FC32; -extern GrB_UnaryOp GxB_LOG2_FC64; -extern GrB_UnaryOp GxB_LOG2_FP32; -extern GrB_UnaryOp GxB_LOG2_FP64; -extern GrB_UnaryOp GxB_LOG_FC32; -extern GrB_UnaryOp GxB_LOG_FC64; -extern GrB_UnaryOp GxB_LOG_FP32; -extern GrB_UnaryOp GxB_LOG_FP64; -extern GrB_UnaryOp GxB_MINV_FC32; -extern GrB_UnaryOp GxB_MINV_FC64; -extern GrB_UnaryOp GxB_ONE_BOOL; -extern GrB_UnaryOp GxB_ONE_FC32; -extern GrB_UnaryOp GxB_ONE_FC64; -extern GrB_UnaryOp GxB_ONE_FP32; -extern GrB_UnaryOp GxB_ONE_FP64; -extern GrB_UnaryOp GxB_ONE_INT8; -extern GrB_UnaryOp GxB_ONE_INT16; -extern GrB_UnaryOp GxB_ONE_INT32; -extern GrB_UnaryOp GxB_ONE_INT64; -extern GrB_UnaryOp GxB_ONE_UINT8; -extern GrB_UnaryOp GxB_ONE_UINT16; -extern GrB_UnaryOp GxB_ONE_UINT32; -extern GrB_UnaryOp GxB_ONE_UINT64; -extern GrB_UnaryOp GxB_POSITIONI1_INT32; -extern GrB_UnaryOp GxB_POSITIONI1_INT64; -extern GrB_UnaryOp GxB_POSITIONI_INT32; -extern GrB_UnaryOp GxB_POSITIONI_INT64; -extern GrB_UnaryOp GxB_POSITIONJ1_INT32; -extern GrB_UnaryOp GxB_POSITIONJ1_INT64; -extern GrB_UnaryOp GxB_POSITIONJ_INT32; -extern GrB_UnaryOp GxB_POSITIONJ_INT64; -extern GrB_UnaryOp GxB_ROUND_FC32; -extern GrB_UnaryOp GxB_ROUND_FC64; -extern GrB_UnaryOp GxB_ROUND_FP32; -extern GrB_UnaryOp GxB_ROUND_FP64; -extern GrB_UnaryOp GxB_SIGNUM_FC32; -extern GrB_UnaryOp GxB_SIGNUM_FC64; -extern GrB_UnaryOp GxB_SIGNUM_FP32; -extern GrB_UnaryOp GxB_SIGNUM_FP64; -extern GrB_UnaryOp GxB_SINH_FC32; -extern GrB_UnaryOp GxB_SINH_FC64; -extern GrB_UnaryOp GxB_SINH_FP32; -extern GrB_UnaryOp GxB_SINH_FP64; -extern GrB_UnaryOp GxB_SIN_FC32; -extern GrB_UnaryOp GxB_SIN_FC64; -extern GrB_UnaryOp GxB_SIN_FP32; -extern GrB_UnaryOp GxB_SIN_FP64; -extern GrB_UnaryOp GxB_SQRT_FC32; -extern GrB_UnaryOp GxB_SQRT_FC64; -extern GrB_UnaryOp GxB_SQRT_FP32; -extern GrB_UnaryOp GxB_SQRT_FP64; -extern GrB_UnaryOp GxB_TANH_FC32; -extern GrB_UnaryOp GxB_TANH_FC64; -extern GrB_UnaryOp GxB_TANH_FP32; -extern GrB_UnaryOp GxB_TANH_FP64; -extern GrB_UnaryOp GxB_TAN_FC32; -extern GrB_UnaryOp GxB_TAN_FC64; -extern GrB_UnaryOp GxB_TAN_FP32; -extern GrB_UnaryOp GxB_TAN_FP64; -extern GrB_UnaryOp GxB_TGAMMA_FP32; -extern GrB_UnaryOp GxB_TGAMMA_FP64; -extern GrB_UnaryOp GxB_TRUNC_FC32; -extern GrB_UnaryOp GxB_TRUNC_FC64; -extern GrB_UnaryOp GxB_TRUNC_FP32; -extern GrB_UnaryOp GxB_TRUNC_FP64; - -/* GxB objects */ -extern GxB_SelectOp GxB_DIAG; -extern GxB_SelectOp GxB_EQ_THUNK; -extern GxB_SelectOp GxB_EQ_ZERO; -extern GxB_SelectOp GxB_GE_THUNK; -extern GxB_SelectOp GxB_GE_ZERO; -extern GxB_SelectOp GxB_GT_THUNK; -extern GxB_SelectOp GxB_GT_ZERO; -extern GxB_SelectOp GxB_LE_THUNK; -extern GxB_SelectOp GxB_LE_ZERO; -extern GxB_SelectOp GxB_LT_THUNK; -extern GxB_SelectOp GxB_LT_ZERO; -extern GxB_SelectOp GxB_NE_THUNK; -extern GxB_SelectOp GxB_NONZERO; -extern GxB_SelectOp GxB_OFFDIAG; -extern GxB_SelectOp GxB_TRIL; -extern GxB_SelectOp GxB_TRIU; - -/**************** -* GrB functions * -****************/ - -/* binary */ -extern GrB_Info GrB_BinaryOp_error(const char **error, const GrB_BinaryOp op); -extern GrB_Info GrB_BinaryOp_free(GrB_BinaryOp *binaryop); -extern GrB_Info GrB_BinaryOp_new(GrB_BinaryOp *binaryop, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); -extern GrB_Info GrB_BinaryOp_wait(GrB_BinaryOp *op); - -/* core */ -extern GrB_Info GrB_finalize(void); -extern GrB_Info GrB_getVersion(unsigned int *version, unsigned int *subversion); -extern GrB_Info GrB_init(GrB_Mode mode); - -/* descriptor */ -extern GrB_Info GrB_Descriptor_error(const char **error, const GrB_Descriptor d); -extern GrB_Info GrB_Descriptor_free(GrB_Descriptor *descriptor); -extern GrB_Info GrB_Descriptor_new(GrB_Descriptor *descriptor); -extern GrB_Info GrB_Descriptor_set(GrB_Descriptor desc, GrB_Desc_Field field, GrB_Desc_Value val); -extern GrB_Info GrB_Descriptor_wait(GrB_Descriptor *desc); - -/* matrix */ -extern GrB_Info GrB_Col_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); -extern GrB_Info GrB_Col_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_build_BOOL(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_FP32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_FP64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT8(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT16(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UDT(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT8(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT16(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_clear(GrB_Matrix A); -extern GrB_Info GrB_Matrix_dup(GrB_Matrix *C, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_eWiseAdd_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseAdd_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseAdd_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseMult_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseMult_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseMult_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_error(const char **error, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extract(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_extractElement_BOOL(bool *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_FP32(float *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_FP64(double *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT8(int8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT16(int16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT32(int32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT64(int64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UDT(void *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT8(uint8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT16(uint16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT32(uint32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT64(uint64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractTuples_BOOL(GrB_Index *I, GrB_Index *J, bool *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_FP32(GrB_Index *I, GrB_Index *J, float *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_FP64(GrB_Index *I, GrB_Index *J, double *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT8(GrB_Index *I, GrB_Index *J, int8_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT16(GrB_Index *I, GrB_Index *J, int16_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT32(GrB_Index *I, GrB_Index *J, int32_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT64(GrB_Index *I, GrB_Index *J, int64_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UDT(GrB_Index *I, GrB_Index *J, void *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT8(GrB_Index *I, GrB_Index *J, uint8_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT16(GrB_Index *I, GrB_Index *J, uint16_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT32(GrB_Index *I, GrB_Index *J, uint32_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT64(GrB_Index *I, GrB_Index *J, uint64_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_free(GrB_Matrix *A); -extern GrB_Info GrB_Matrix_kronecker_BinaryOp(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_kronecker_Monoid(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_kronecker_Semiring(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_ncols(GrB_Index *ncols, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_new(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols); -extern GrB_Info GrB_Matrix_nrows(GrB_Index *nrows, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_nvals(GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_removeElement(GrB_Matrix C, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_resize(GrB_Matrix C, GrB_Index nrows_new, GrB_Index ncols_new); -extern GrB_Info GrB_Matrix_setElement_BOOL(GrB_Matrix C, bool x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_FP32(GrB_Matrix C, float x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_FP64(GrB_Matrix C, double x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT8(GrB_Matrix C, int8_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT16(GrB_Matrix C, int16_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT32(GrB_Matrix C, int32_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT64(GrB_Matrix C, int64_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UDT(GrB_Matrix C, void *x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT8(GrB_Matrix C, uint8_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT16(GrB_Matrix C, uint16_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT32(GrB_Matrix C, uint32_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT64(GrB_Matrix C, uint64_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_wait(GrB_Matrix *A); -extern GrB_Info GrB_Row_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_mxm(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_mxv(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_transpose(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_vxm(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Matrix A, const GrB_Descriptor desc); - -/* monoid */ -extern GrB_Info GrB_Monoid_error(const char **error, const GrB_Monoid monoid); -extern GrB_Info GrB_Monoid_free(GrB_Monoid *monoid); -extern GrB_Info GrB_Monoid_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity); -extern GrB_Info GrB_Monoid_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity); -extern GrB_Info GrB_Monoid_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity); -extern GrB_Info GrB_Monoid_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity); -extern GrB_Info GrB_Monoid_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity); -extern GrB_Info GrB_Monoid_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity); -extern GrB_Info GrB_Monoid_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity); -extern GrB_Info GrB_Monoid_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity); -extern GrB_Info GrB_Monoid_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity); -extern GrB_Info GrB_Monoid_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity); -extern GrB_Info GrB_Monoid_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity); -extern GrB_Info GrB_Monoid_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity); -extern GrB_Info GrB_Monoid_wait(GrB_Monoid *monoid); - -/* semiring */ -extern GrB_Info GrB_Semiring_error(const char **error, const GrB_Semiring semiring); -extern GrB_Info GrB_Semiring_free(GrB_Semiring *semiring); -extern GrB_Info GrB_Semiring_new(GrB_Semiring *semiring, GrB_Monoid add, GrB_BinaryOp multiply); -extern GrB_Info GrB_Semiring_wait(GrB_Semiring *semiring); - -/* type */ -extern GrB_Info GrB_Type_error(const char **error, const GrB_Type type); -extern GrB_Info GrB_Type_free(GrB_Type *type); -extern GrB_Info GrB_Type_new(GrB_Type *type, size_t sizeof_ctype); -extern GrB_Info GrB_Type_wait(GrB_Type *type); - -/* unary */ -extern GrB_Info GrB_UnaryOp_error(const char **error, const GrB_UnaryOp op); -extern GrB_Info GrB_UnaryOp_free(GrB_UnaryOp *unaryop); -extern GrB_Info GrB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype); -extern GrB_Info GrB_UnaryOp_wait(GrB_UnaryOp *op); - -/* vector */ -extern GrB_Info GrB_Vector_apply(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_build_BOOL(GrB_Vector w, const GrB_Index *I, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_FP32(GrB_Vector w, const GrB_Index *I, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_FP64(GrB_Vector w, const GrB_Index *I, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT8(GrB_Vector w, const GrB_Index *I, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT16(GrB_Vector w, const GrB_Index *I, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT32(GrB_Vector w, const GrB_Index *I, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT64(GrB_Vector w, const GrB_Index *I, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UDT(GrB_Vector w, const GrB_Index *I, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT8(GrB_Vector w, const GrB_Index *I, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT16(GrB_Vector w, const GrB_Index *I, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT32(GrB_Vector w, const GrB_Index *I, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT64(GrB_Vector w, const GrB_Index *I, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_clear(GrB_Vector v); -extern GrB_Info GrB_Vector_dup(GrB_Vector *w, const GrB_Vector u); -extern GrB_Info GrB_Vector_eWiseAdd_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseAdd_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseAdd_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseMult_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseMult_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseMult_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_error(const char **error, const GrB_Vector v); -extern GrB_Info GrB_Vector_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_extractElement_BOOL(bool *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_FP32(float *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_FP64(double *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT8(int8_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT16(int16_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT32(int32_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT64(int64_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UDT(void *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT8(uint8_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT16(uint16_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT32(uint32_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT64(uint64_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractTuples_BOOL(GrB_Index *I, bool *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_FP32(GrB_Index *I, float *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_FP64(GrB_Index *I, double *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT8(GrB_Index *I, int8_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT16(GrB_Index *I, int16_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT32(GrB_Index *I, int32_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT64(GrB_Index *I, int64_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UDT(GrB_Index *I, void *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT8(GrB_Index *I, uint8_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT16(GrB_Index *I, uint16_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT32(GrB_Index *I, uint32_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT64(GrB_Index *I, uint64_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_free(GrB_Vector *v); -extern GrB_Info GrB_Vector_new(GrB_Vector *v, GrB_Type type, GrB_Index n); -extern GrB_Info GrB_Vector_nvals(GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_removeElement(GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_resize(GrB_Vector w, GrB_Index nrows_new); -extern GrB_Info GrB_Vector_setElement_BOOL(GrB_Vector w, bool x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_FP32(GrB_Vector w, float x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_FP64(GrB_Vector w, double x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT8(GrB_Vector w, int8_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT16(GrB_Vector w, int16_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT32(GrB_Vector w, int32_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT64(GrB_Vector w, int64_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UDT(GrB_Vector w, void *x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT8(GrB_Vector w, uint8_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT16(GrB_Vector w, uint16_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT32(GrB_Vector w, uint32_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT64(GrB_Vector w, uint64_t x, GrB_Index i); -extern GrB_Info GrB_Vector_size(GrB_Index *n, const GrB_Vector v); -extern GrB_Info GrB_Vector_wait(GrB_Vector *v); - -/*************** -* GB functions * -***************/ - -/* binary */ -extern GrB_Info GB_BinaryOp_new(GrB_BinaryOp *binaryop, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *name); - -/* selectop */ -extern GrB_Info GB_SelectOp_new(GxB_SelectOp *selectop, GxB_select_function function, GrB_Type xtype, GrB_Type ttype, const char *name); - -/* type */ -extern GrB_Info GB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *name); - -/* unary */ -extern GrB_Info GB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *name); - -/**************** -* GxB functions * -****************/ - -/* binary */ -extern GrB_Info GxB_BinaryOp_fprint(GrB_BinaryOp binaryop, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_BinaryOp_xtype(GrB_Type *xtype, GrB_BinaryOp binaryop); -extern GrB_Info GxB_BinaryOp_ytype(GrB_Type *ytype, GrB_BinaryOp binaryop); -extern GrB_Info GxB_BinaryOp_ztype(GrB_Type *ztype, GrB_BinaryOp binaryop); - -/* core */ -extern GrB_Info GxB_Global_Option_get(GxB_Option_Field field, ...); -extern GrB_Info GxB_Global_Option_set(GxB_Option_Field field, ...); -extern GrB_Info GxB_cuda_init(GrB_Mode mode); -extern GrB_Info GxB_init(GrB_Mode mode, void *(*user_malloc_function)(size_t), void *(*user_calloc_function)(size_t, size_t), void *(*user_realloc_function)(void *, size_t), void (*user_free_function)(void *), bool user_malloc_is_thread_safe); - -/* descriptor */ -extern GrB_Info GxB_Desc_get(GrB_Descriptor desc, GrB_Desc_Field field, ...); -extern GrB_Info GxB_Desc_set(GrB_Descriptor desc, GrB_Desc_Field field, ...); -extern GrB_Info GxB_Descriptor_fprint(GrB_Descriptor descriptor, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Descriptor_get(GrB_Desc_Value *val, GrB_Descriptor desc, GrB_Desc_Field field); - -/* matrix */ -extern GrB_Info GxB_Col_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_Option_get(GrB_Matrix A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Matrix_Option_set(GrB_Matrix A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Matrix_apply_BinaryOp1st(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GxB_Scalar x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_apply_BinaryOp1st_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC32_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_apply_BinaryOp1st_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC64_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_apply_BinaryOp2nd(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GxB_Scalar y, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_apply_BinaryOp2nd_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, GxB_FC32_t y, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_apply_BinaryOp2nd_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, GxB_FC64_t y, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_assign_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_assign_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_build_FC32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const GxB_FC32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GxB_Matrix_build_FC64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const GxB_FC64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GxB_Matrix_export_BitmapC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, GrB_Index *nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_BitmapR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, GrB_Index *nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_CSC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ai_size, GrB_Index *Ax_size, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_CSR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Aj_size, GrB_Index *Ax_size, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_FullC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, void **Ax, GrB_Index *Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_FullR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, void **Ax, GrB_Index *Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_HyperCSC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ah_size, GrB_Index *Ai_size, GrB_Index *Ax_size, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_HyperCSR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Ah_size, GrB_Index *Aj_size, GrB_Index *Ax_size, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_extractElement_FC32(GxB_FC32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GxB_Matrix_extractElement_FC64(GxB_FC64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GxB_Matrix_extractTuples_FC32(GrB_Index *I, GrB_Index *J, GxB_FC32_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GxB_Matrix_extractTuples_FC64(GrB_Index *I, GrB_Index *J, GxB_FC64_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GxB_Matrix_fprint(GrB_Matrix A, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Matrix_import_BitmapC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, GrB_Index nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_BitmapR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, GrB_Index nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_CSC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ai_size, GrB_Index Ax_size, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_CSR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Aj_size, GrB_Index Ax_size, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_FullC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, void **Ax, GrB_Index Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_FullR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, void **Ax, GrB_Index Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_HyperCSC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ah_size, GrB_Index Ai_size, GrB_Index Ax_size, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_HyperCSR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Ah_size, GrB_Index Aj_size, GrB_Index Ax_size, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_reduce_FC32(GxB_FC32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_reduce_FC64(GxB_FC64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_select(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GxB_SelectOp op, const GrB_Matrix A, const GxB_Scalar Thunk, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_setElement_FC32(GrB_Matrix C, GxB_FC32_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GxB_Matrix_setElement_FC64(GrB_Matrix C, GxB_FC64_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GxB_Matrix_subassign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_type(GrB_Type *type, const GrB_Matrix A); -extern GrB_Info GxB_Row_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); - -/* monoid */ -extern GrB_Info GxB_Monoid_fprint(GrB_Monoid monoid, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Monoid_identity(void *identity, GrB_Monoid monoid); -extern GrB_Info GxB_Monoid_new_FC32(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC32_t identity); -extern GrB_Info GxB_Monoid_new_FC64(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC64_t identity); -extern GrB_Info GxB_Monoid_operator(GrB_BinaryOp *op, GrB_Monoid monoid); -extern GrB_Info GxB_Monoid_terminal(bool *has_terminal, void *terminal, GrB_Monoid monoid); -extern GrB_Info GxB_Monoid_terminal_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, bool terminal); -extern GrB_Info GxB_Monoid_terminal_new_FC32(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC32_t identity, GxB_FC32_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_FC64(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC64_t identity, GxB_FC64_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, float terminal); -extern GrB_Info GxB_Monoid_terminal_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, double terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, int8_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, int16_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, int32_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, int64_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, void *terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, uint8_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, uint16_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, uint32_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, uint64_t terminal); - -/* scalar */ -extern GrB_Info GxB_Scalar_clear(GxB_Scalar s); -extern GrB_Info GxB_Scalar_dup(GxB_Scalar *s, const GxB_Scalar t); -extern GrB_Info GxB_Scalar_error(const char **error, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_BOOL(bool *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_FC32(GxB_FC32_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_FC64(GxB_FC64_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_FP32(float *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_FP64(double *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT8(int8_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT16(int16_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT32(int32_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT64(int64_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UDT(void *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_fprint(GxB_Scalar s, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Scalar_free(GxB_Scalar *s); -extern GrB_Info GxB_Scalar_new(GxB_Scalar *s, GrB_Type type); -extern GrB_Info GxB_Scalar_nvals(GrB_Index *nvals, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_setElement_BOOL(GxB_Scalar s, bool x); -extern GrB_Info GxB_Scalar_setElement_FC32(GxB_Scalar s, GxB_FC32_t x); -extern GrB_Info GxB_Scalar_setElement_FC64(GxB_Scalar s, GxB_FC64_t x); -extern GrB_Info GxB_Scalar_setElement_FP32(GxB_Scalar s, float x); -extern GrB_Info GxB_Scalar_setElement_FP64(GxB_Scalar s, double x); -extern GrB_Info GxB_Scalar_setElement_INT8(GxB_Scalar s, int8_t x); -extern GrB_Info GxB_Scalar_setElement_INT16(GxB_Scalar s, int16_t x); -extern GrB_Info GxB_Scalar_setElement_INT32(GxB_Scalar s, int32_t x); -extern GrB_Info GxB_Scalar_setElement_INT64(GxB_Scalar s, int64_t x); -extern GrB_Info GxB_Scalar_setElement_UDT(GxB_Scalar s, void *x); -extern GrB_Info GxB_Scalar_setElement_UINT8(GxB_Scalar s, uint8_t x); -extern GrB_Info GxB_Scalar_setElement_UINT16(GxB_Scalar s, uint16_t x); -extern GrB_Info GxB_Scalar_setElement_UINT32(GxB_Scalar s, uint32_t x); -extern GrB_Info GxB_Scalar_setElement_UINT64(GxB_Scalar s, uint64_t x); -extern GrB_Info GxB_Scalar_type(GrB_Type *type, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_wait(GxB_Scalar *s); - -/* selectop */ -extern GrB_Info GxB_SelectOp_error(const char **error, const GxB_SelectOp op); -extern GrB_Info GxB_SelectOp_fprint(GxB_SelectOp selectop, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_SelectOp_free(GxB_SelectOp *selectop); -extern GrB_Info GxB_SelectOp_new(GxB_SelectOp *selectop, GxB_select_function function, GrB_Type xtype, GrB_Type ttype); -extern GrB_Info GxB_SelectOp_ttype(GrB_Type *ttype, GxB_SelectOp selectop); -extern GrB_Info GxB_SelectOp_wait(GxB_SelectOp *op); -extern GrB_Info GxB_SelectOp_xtype(GrB_Type *xtype, GxB_SelectOp selectop); - -/* semiring */ -extern GrB_Info GxB_Semiring_add(GrB_Monoid *add, GrB_Semiring semiring); -extern GrB_Info GxB_Semiring_fprint(GrB_Semiring semiring, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Semiring_multiply(GrB_BinaryOp *multiply, GrB_Semiring semiring); - -/* type */ -extern GrB_Info GxB_Type_fprint(GrB_Type type, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Type_size(size_t *size, GrB_Type type); - -/* unary */ -extern GrB_Info GxB_UnaryOp_fprint(GrB_UnaryOp unaryop, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_UnaryOp_xtype(GrB_Type *xtype, GrB_UnaryOp unaryop); -extern GrB_Info GxB_UnaryOp_ztype(GrB_Type *ztype, GrB_UnaryOp unaryop); - -/* vector */ -extern GrB_Info GxB_Vector_Option_get(GrB_Vector A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Vector_Option_set(GrB_Vector A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Vector_apply_BinaryOp1st(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GxB_Scalar x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_apply_BinaryOp1st_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC32_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_apply_BinaryOp1st_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC64_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_apply_BinaryOp2nd(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const GxB_Scalar y, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_apply_BinaryOp2nd_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, GxB_FC32_t y, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_apply_BinaryOp2nd_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, GxB_FC64_t y, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_assign_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_assign_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_build_FC32(GrB_Vector w, const GrB_Index *I, const GxB_FC32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GxB_Vector_build_FC64(GrB_Vector w, const GrB_Index *I, const GxB_FC64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GxB_Vector_export_Bitmap(GrB_Vector *v, GrB_Type *type, GrB_Index *n, int8_t **vb, void **vx, GrB_Index *vb_size, GrB_Index *vx_size, GrB_Index *nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_export_CSC(GrB_Vector *v, GrB_Type *type, GrB_Index *n, GrB_Index **vi, void **vx, GrB_Index *vi_size, GrB_Index *vx_size, GrB_Index *nvals, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_export_Full(GrB_Vector *v, GrB_Type *type, GrB_Index *n, void **vx, GrB_Index *vx_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_extractElement_FC32(GxB_FC32_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GxB_Vector_extractElement_FC64(GxB_FC64_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GxB_Vector_extractTuples_FC32(GrB_Index *I, GxB_FC32_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GxB_Vector_extractTuples_FC64(GrB_Index *I, GxB_FC64_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GxB_Vector_fprint(GrB_Vector v, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Vector_import_Bitmap(GrB_Vector *v, GrB_Type type, GrB_Index n, int8_t **vb, void **vx, GrB_Index vb_size, GrB_Index vx_size, GrB_Index nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_import_CSC(GrB_Vector *v, GrB_Type type, GrB_Index n, GrB_Index **vi, void **vx, GrB_Index vi_size, GrB_Index vx_size, GrB_Index nvals, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_import_Full(GrB_Vector *v, GrB_Type type, GrB_Index n, void **vx, GrB_Index vx_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_reduce_FC32(GxB_FC32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_reduce_FC64(GxB_FC64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_select(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GxB_SelectOp op, const GrB_Vector u, const GxB_Scalar Thunk, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_setElement_FC32(GrB_Vector w, GxB_FC32_t x, GrB_Index i); -extern GrB_Info GxB_Vector_setElement_FC64(GrB_Vector w, GxB_FC64_t x, GrB_Index i); -extern GrB_Info GxB_Vector_subassign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_type(GrB_Type *type, const GrB_Vector v); - -/* int DEFINES */ -#define GRB_SUBVERSION ... -#define GRB_VERSION ... -#define GxB_ANY_SPARSITY ... -#define GxB_AUTO_SPARSITY ... -#define GxB_BACKWARDS ... -#define GxB_BEGIN ... -#define GxB_BITMAP ... -#define GxB_CHUNK ... -#define GxB_END ... -#define GxB_FULL ... -#define GxB_GPU_CHUNK ... -#define GxB_GPU_CONTROL ... -#define GxB_HYPERSPARSE ... -#define GxB_IMPLEMENTATION ... -#define GxB_IMPLEMENTATION_MAJOR ... -#define GxB_IMPLEMENTATION_MINOR ... -#define GxB_IMPLEMENTATION_SUB ... -#define GxB_INC ... -#define GxB_INDEX_MAX ... -#define GxB_NBITMAP_SWITCH ... -#define GxB_NTHREADS ... -#define GxB_RANGE ... -#define GxB_SPARSE ... -#define GxB_SPEC_MAJOR ... -#define GxB_SPEC_MINOR ... -#define GxB_SPEC_SUB ... -#define GxB_SPEC_VERSION ... -#define GxB_STDC_VERSION ... -#define GxB_STRIDE ... - -/* char* DEFINES */ -extern char *GxB_IMPLEMENTATION_ABOUT_STR; -extern char *GxB_IMPLEMENTATION_DATE_STR; -extern char *GxB_IMPLEMENTATION_LICENSE_STR; -extern char *GxB_IMPLEMENTATION_NAME_STR; -extern char *GxB_SPEC_ABOUT_STR; -extern char *GxB_SPEC_DATE_STR; \ No newline at end of file diff --git a/suitesparse/graphblas/suitesparse_graphblas_no_complex.h b/suitesparse/graphblas/suitesparse_graphblas_no_complex.h deleted file mode 100644 index 63271e3..0000000 --- a/suitesparse/graphblas/suitesparse_graphblas_no_complex.h +++ /dev/null @@ -1,2846 +0,0 @@ -/* This file is automatically generated */ -/* GrB typedefs */ -typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; -typedef struct GB_Descriptor_opaque *GrB_Descriptor; -typedef struct GB_Matrix_opaque *GrB_Matrix; -typedef struct GB_Monoid_opaque *GrB_Monoid; -typedef struct GB_Semiring_opaque *GrB_Semiring; -typedef struct GB_Type_opaque *GrB_Type; -typedef struct GB_UnaryOp_opaque *GrB_UnaryOp; -typedef struct GB_Vector_opaque *GrB_Vector; -typedef uint64_t GrB_Index; - -/* GxB typedefs */ -typedef struct GB_Scalar_opaque *GxB_Scalar; -typedef struct GB_SelectOp_opaque *GxB_SelectOp; - -/* GxB typedefs (functions) */ -typedef bool (*GxB_select_function)(GrB_Index i, GrB_Index j, const void *x, const void *thunk); -typedef void (*GxB_binary_function)(void *, const void *, const void *); -typedef void (*GxB_unary_function)(void *, const void *); - -/* GrB enums */ -typedef enum -{ - GrB_OUTP = 0, - GrB_MASK = 1, - GrB_INP0 = 2, - GrB_INP1 = 3, - GxB_DESCRIPTOR_NTHREADS = 5, - GxB_DESCRIPTOR_CHUNK = 7, - GxB_DESCRIPTOR_GPU_CONTROL = 21, - GxB_DESCRIPTOR_GPU_CHUNK = 22, - GxB_AxB_METHOD = 1000, - GxB_SORT = 35 -} GrB_Desc_Field; - -typedef enum -{ - GxB_DEFAULT = 0, - GrB_REPLACE = 1, - GrB_COMP = 2, - GrB_STRUCTURE = 4, - GrB_TRAN = 3, - GxB_GPU_ALWAYS = 2001, - GxB_GPU_NEVER = 2002, - GxB_AxB_GUSTAVSON = 1001, - GxB_AxB_DOT = 1003, - GxB_AxB_HASH = 1004, - GxB_AxB_SAXPY = 1005 -} GrB_Desc_Value; - -typedef enum -{ - GrB_SUCCESS = 0, - GrB_NO_VALUE = 1, - GrB_UNINITIALIZED_OBJECT = 2, - GrB_INVALID_OBJECT = 3, - GrB_NULL_POINTER = 4, - GrB_INVALID_VALUE = 5, - GrB_INVALID_INDEX = 6, - GrB_DOMAIN_MISMATCH = 7, - GrB_DIMENSION_MISMATCH = 8, - GrB_OUTPUT_NOT_EMPTY = 9, - GrB_OUT_OF_MEMORY = 10, - GrB_INSUFFICIENT_SPACE = 11, - GrB_INDEX_OUT_OF_BOUNDS = 12, - GrB_PANIC = 13 -} GrB_Info; - -typedef enum -{ - GrB_NONBLOCKING = 0, - GrB_BLOCKING = 1 -} GrB_Mode; - -/* GxB enums */ -typedef enum -{ - GxB_BY_ROW = 0, - GxB_BY_COL = 1, - GxB_NO_FORMAT = -1 -} GxB_Format_Value; - -typedef enum -{ - GxB_HYPER_SWITCH = 0, - GxB_BITMAP_SWITCH = 34, - GxB_FORMAT = 1, - GxB_MODE = 2, - GxB_LIBRARY_NAME = 8, - GxB_LIBRARY_VERSION = 9, - GxB_LIBRARY_DATE = 10, - GxB_LIBRARY_ABOUT = 11, - GxB_LIBRARY_URL = 12, - GxB_LIBRARY_LICENSE = 13, - GxB_LIBRARY_COMPILE_DATE = 14, - GxB_LIBRARY_COMPILE_TIME = 15, - GxB_API_VERSION = 16, - GxB_API_DATE = 17, - GxB_API_ABOUT = 18, - GxB_API_URL = 19, - GxB_GLOBAL_NTHREADS = 5, - GxB_GLOBAL_CHUNK = 7, - GxB_BURBLE = 99, - GxB_SPARSITY_STATUS = 33, - GxB_SPARSITY_CONTROL = 32, - GxB_GLOBAL_GPU_CONTROL = 21, - GxB_GLOBAL_GPU_CHUNK = 22 -} GxB_Option_Field; - -typedef enum -{ - GxB_SILENT = 0, - GxB_SUMMARY = 1, - GxB_SHORT = 2, - GxB_COMPLETE = 3, - GxB_SHORT_VERBOSE = 4, - GxB_COMPLETE_VERBOSE = 5 -} GxB_Print_Level; - -/* GrB consts */ -extern const uint64_t *GrB_ALL; - -/* GxB consts */ -extern const GxB_Format_Value GxB_FORMAT_DEFAULT; -extern const double GxB_ALWAYS_HYPER; -extern const double GxB_HYPER_DEFAULT; -extern const double GxB_NEVER_HYPER; - -/* GrB objects */ -extern GrB_BinaryOp GrB_BAND_INT8; -extern GrB_BinaryOp GrB_BAND_INT16; -extern GrB_BinaryOp GrB_BAND_INT32; -extern GrB_BinaryOp GrB_BAND_INT64; -extern GrB_BinaryOp GrB_BAND_UINT8; -extern GrB_BinaryOp GrB_BAND_UINT16; -extern GrB_BinaryOp GrB_BAND_UINT32; -extern GrB_BinaryOp GrB_BAND_UINT64; -extern GrB_BinaryOp GrB_BOR_INT8; -extern GrB_BinaryOp GrB_BOR_INT16; -extern GrB_BinaryOp GrB_BOR_INT32; -extern GrB_BinaryOp GrB_BOR_INT64; -extern GrB_BinaryOp GrB_BOR_UINT8; -extern GrB_BinaryOp GrB_BOR_UINT16; -extern GrB_BinaryOp GrB_BOR_UINT32; -extern GrB_BinaryOp GrB_BOR_UINT64; -extern GrB_BinaryOp GrB_BXNOR_INT8; -extern GrB_BinaryOp GrB_BXNOR_INT16; -extern GrB_BinaryOp GrB_BXNOR_INT32; -extern GrB_BinaryOp GrB_BXNOR_INT64; -extern GrB_BinaryOp GrB_BXNOR_UINT8; -extern GrB_BinaryOp GrB_BXNOR_UINT16; -extern GrB_BinaryOp GrB_BXNOR_UINT32; -extern GrB_BinaryOp GrB_BXNOR_UINT64; -extern GrB_BinaryOp GrB_BXOR_INT8; -extern GrB_BinaryOp GrB_BXOR_INT16; -extern GrB_BinaryOp GrB_BXOR_INT32; -extern GrB_BinaryOp GrB_BXOR_INT64; -extern GrB_BinaryOp GrB_BXOR_UINT8; -extern GrB_BinaryOp GrB_BXOR_UINT16; -extern GrB_BinaryOp GrB_BXOR_UINT32; -extern GrB_BinaryOp GrB_BXOR_UINT64; -extern GrB_BinaryOp GrB_DIV_BOOL; -extern GrB_BinaryOp GrB_DIV_FP32; -extern GrB_BinaryOp GrB_DIV_FP64; -extern GrB_BinaryOp GrB_DIV_INT8; -extern GrB_BinaryOp GrB_DIV_INT16; -extern GrB_BinaryOp GrB_DIV_INT32; -extern GrB_BinaryOp GrB_DIV_INT64; -extern GrB_BinaryOp GrB_DIV_UINT8; -extern GrB_BinaryOp GrB_DIV_UINT16; -extern GrB_BinaryOp GrB_DIV_UINT32; -extern GrB_BinaryOp GrB_DIV_UINT64; -extern GrB_BinaryOp GrB_EQ_BOOL; -extern GrB_BinaryOp GrB_EQ_FP32; -extern GrB_BinaryOp GrB_EQ_FP64; -extern GrB_BinaryOp GrB_EQ_INT8; -extern GrB_BinaryOp GrB_EQ_INT16; -extern GrB_BinaryOp GrB_EQ_INT32; -extern GrB_BinaryOp GrB_EQ_INT64; -extern GrB_BinaryOp GrB_EQ_UINT8; -extern GrB_BinaryOp GrB_EQ_UINT16; -extern GrB_BinaryOp GrB_EQ_UINT32; -extern GrB_BinaryOp GrB_EQ_UINT64; -extern GrB_BinaryOp GrB_FIRST_BOOL; -extern GrB_BinaryOp GrB_FIRST_FP32; -extern GrB_BinaryOp GrB_FIRST_FP64; -extern GrB_BinaryOp GrB_FIRST_INT8; -extern GrB_BinaryOp GrB_FIRST_INT16; -extern GrB_BinaryOp GrB_FIRST_INT32; -extern GrB_BinaryOp GrB_FIRST_INT64; -extern GrB_BinaryOp GrB_FIRST_UINT8; -extern GrB_BinaryOp GrB_FIRST_UINT16; -extern GrB_BinaryOp GrB_FIRST_UINT32; -extern GrB_BinaryOp GrB_FIRST_UINT64; -extern GrB_BinaryOp GrB_GE_BOOL; -extern GrB_BinaryOp GrB_GE_FP32; -extern GrB_BinaryOp GrB_GE_FP64; -extern GrB_BinaryOp GrB_GE_INT8; -extern GrB_BinaryOp GrB_GE_INT16; -extern GrB_BinaryOp GrB_GE_INT32; -extern GrB_BinaryOp GrB_GE_INT64; -extern GrB_BinaryOp GrB_GE_UINT8; -extern GrB_BinaryOp GrB_GE_UINT16; -extern GrB_BinaryOp GrB_GE_UINT32; -extern GrB_BinaryOp GrB_GE_UINT64; -extern GrB_BinaryOp GrB_GT_BOOL; -extern GrB_BinaryOp GrB_GT_FP32; -extern GrB_BinaryOp GrB_GT_FP64; -extern GrB_BinaryOp GrB_GT_INT8; -extern GrB_BinaryOp GrB_GT_INT16; -extern GrB_BinaryOp GrB_GT_INT32; -extern GrB_BinaryOp GrB_GT_INT64; -extern GrB_BinaryOp GrB_GT_UINT8; -extern GrB_BinaryOp GrB_GT_UINT16; -extern GrB_BinaryOp GrB_GT_UINT32; -extern GrB_BinaryOp GrB_GT_UINT64; -extern GrB_BinaryOp GrB_LAND; -extern GrB_BinaryOp GrB_LE_BOOL; -extern GrB_BinaryOp GrB_LE_FP32; -extern GrB_BinaryOp GrB_LE_FP64; -extern GrB_BinaryOp GrB_LE_INT8; -extern GrB_BinaryOp GrB_LE_INT16; -extern GrB_BinaryOp GrB_LE_INT32; -extern GrB_BinaryOp GrB_LE_INT64; -extern GrB_BinaryOp GrB_LE_UINT8; -extern GrB_BinaryOp GrB_LE_UINT16; -extern GrB_BinaryOp GrB_LE_UINT32; -extern GrB_BinaryOp GrB_LE_UINT64; -extern GrB_BinaryOp GrB_LOR; -extern GrB_BinaryOp GrB_LT_BOOL; -extern GrB_BinaryOp GrB_LT_FP32; -extern GrB_BinaryOp GrB_LT_FP64; -extern GrB_BinaryOp GrB_LT_INT8; -extern GrB_BinaryOp GrB_LT_INT16; -extern GrB_BinaryOp GrB_LT_INT32; -extern GrB_BinaryOp GrB_LT_INT64; -extern GrB_BinaryOp GrB_LT_UINT8; -extern GrB_BinaryOp GrB_LT_UINT16; -extern GrB_BinaryOp GrB_LT_UINT32; -extern GrB_BinaryOp GrB_LT_UINT64; -extern GrB_BinaryOp GrB_LXNOR; -extern GrB_BinaryOp GrB_LXOR; -extern GrB_BinaryOp GrB_MAX_BOOL; -extern GrB_BinaryOp GrB_MAX_FP32; -extern GrB_BinaryOp GrB_MAX_FP64; -extern GrB_BinaryOp GrB_MAX_INT8; -extern GrB_BinaryOp GrB_MAX_INT16; -extern GrB_BinaryOp GrB_MAX_INT32; -extern GrB_BinaryOp GrB_MAX_INT64; -extern GrB_BinaryOp GrB_MAX_UINT8; -extern GrB_BinaryOp GrB_MAX_UINT16; -extern GrB_BinaryOp GrB_MAX_UINT32; -extern GrB_BinaryOp GrB_MAX_UINT64; -extern GrB_BinaryOp GrB_MINUS_BOOL; -extern GrB_BinaryOp GrB_MINUS_FP32; -extern GrB_BinaryOp GrB_MINUS_FP64; -extern GrB_BinaryOp GrB_MINUS_INT8; -extern GrB_BinaryOp GrB_MINUS_INT16; -extern GrB_BinaryOp GrB_MINUS_INT32; -extern GrB_BinaryOp GrB_MINUS_INT64; -extern GrB_BinaryOp GrB_MINUS_UINT8; -extern GrB_BinaryOp GrB_MINUS_UINT16; -extern GrB_BinaryOp GrB_MINUS_UINT32; -extern GrB_BinaryOp GrB_MINUS_UINT64; -extern GrB_BinaryOp GrB_MIN_BOOL; -extern GrB_BinaryOp GrB_MIN_FP32; -extern GrB_BinaryOp GrB_MIN_FP64; -extern GrB_BinaryOp GrB_MIN_INT8; -extern GrB_BinaryOp GrB_MIN_INT16; -extern GrB_BinaryOp GrB_MIN_INT32; -extern GrB_BinaryOp GrB_MIN_INT64; -extern GrB_BinaryOp GrB_MIN_UINT8; -extern GrB_BinaryOp GrB_MIN_UINT16; -extern GrB_BinaryOp GrB_MIN_UINT32; -extern GrB_BinaryOp GrB_MIN_UINT64; -extern GrB_BinaryOp GrB_NE_BOOL; -extern GrB_BinaryOp GrB_NE_FP32; -extern GrB_BinaryOp GrB_NE_FP64; -extern GrB_BinaryOp GrB_NE_INT8; -extern GrB_BinaryOp GrB_NE_INT16; -extern GrB_BinaryOp GrB_NE_INT32; -extern GrB_BinaryOp GrB_NE_INT64; -extern GrB_BinaryOp GrB_NE_UINT8; -extern GrB_BinaryOp GrB_NE_UINT16; -extern GrB_BinaryOp GrB_NE_UINT32; -extern GrB_BinaryOp GrB_NE_UINT64; -extern GrB_BinaryOp GrB_PLUS_BOOL; -extern GrB_BinaryOp GrB_PLUS_FP32; -extern GrB_BinaryOp GrB_PLUS_FP64; -extern GrB_BinaryOp GrB_PLUS_INT8; -extern GrB_BinaryOp GrB_PLUS_INT16; -extern GrB_BinaryOp GrB_PLUS_INT32; -extern GrB_BinaryOp GrB_PLUS_INT64; -extern GrB_BinaryOp GrB_PLUS_UINT8; -extern GrB_BinaryOp GrB_PLUS_UINT16; -extern GrB_BinaryOp GrB_PLUS_UINT32; -extern GrB_BinaryOp GrB_PLUS_UINT64; -extern GrB_BinaryOp GrB_SECOND_BOOL; -extern GrB_BinaryOp GrB_SECOND_FP32; -extern GrB_BinaryOp GrB_SECOND_FP64; -extern GrB_BinaryOp GrB_SECOND_INT8; -extern GrB_BinaryOp GrB_SECOND_INT16; -extern GrB_BinaryOp GrB_SECOND_INT32; -extern GrB_BinaryOp GrB_SECOND_INT64; -extern GrB_BinaryOp GrB_SECOND_UINT8; -extern GrB_BinaryOp GrB_SECOND_UINT16; -extern GrB_BinaryOp GrB_SECOND_UINT32; -extern GrB_BinaryOp GrB_SECOND_UINT64; -extern GrB_BinaryOp GrB_TIMES_BOOL; -extern GrB_BinaryOp GrB_TIMES_FP32; -extern GrB_BinaryOp GrB_TIMES_FP64; -extern GrB_BinaryOp GrB_TIMES_INT8; -extern GrB_BinaryOp GrB_TIMES_INT16; -extern GrB_BinaryOp GrB_TIMES_INT32; -extern GrB_BinaryOp GrB_TIMES_INT64; -extern GrB_BinaryOp GrB_TIMES_UINT8; -extern GrB_BinaryOp GrB_TIMES_UINT16; -extern GrB_BinaryOp GrB_TIMES_UINT32; -extern GrB_BinaryOp GrB_TIMES_UINT64; -extern GrB_Descriptor GrB_DESC_C; -extern GrB_Descriptor GrB_DESC_CT0; -extern GrB_Descriptor GrB_DESC_CT0T1; -extern GrB_Descriptor GrB_DESC_CT1; -extern GrB_Descriptor GrB_DESC_R; -extern GrB_Descriptor GrB_DESC_RC; -extern GrB_Descriptor GrB_DESC_RCT0; -extern GrB_Descriptor GrB_DESC_RCT0T1; -extern GrB_Descriptor GrB_DESC_RCT1; -extern GrB_Descriptor GrB_DESC_RS; -extern GrB_Descriptor GrB_DESC_RSC; -extern GrB_Descriptor GrB_DESC_RSCT0; -extern GrB_Descriptor GrB_DESC_RSCT0T1; -extern GrB_Descriptor GrB_DESC_RSCT1; -extern GrB_Descriptor GrB_DESC_RST0; -extern GrB_Descriptor GrB_DESC_RST0T1; -extern GrB_Descriptor GrB_DESC_RST1; -extern GrB_Descriptor GrB_DESC_RT0; -extern GrB_Descriptor GrB_DESC_RT0T1; -extern GrB_Descriptor GrB_DESC_RT1; -extern GrB_Descriptor GrB_DESC_S; -extern GrB_Descriptor GrB_DESC_SC; -extern GrB_Descriptor GrB_DESC_SCT0; -extern GrB_Descriptor GrB_DESC_SCT0T1; -extern GrB_Descriptor GrB_DESC_SCT1; -extern GrB_Descriptor GrB_DESC_ST0; -extern GrB_Descriptor GrB_DESC_ST0T1; -extern GrB_Descriptor GrB_DESC_ST1; -extern GrB_Descriptor GrB_DESC_T0; -extern GrB_Descriptor GrB_DESC_T0T1; -extern GrB_Descriptor GrB_DESC_T1; -extern GrB_Monoid GrB_LAND_MONOID_BOOL; -extern GrB_Monoid GrB_LOR_MONOID_BOOL; -extern GrB_Monoid GrB_LXNOR_MONOID_BOOL; -extern GrB_Monoid GrB_LXOR_MONOID_BOOL; -extern GrB_Monoid GrB_MAX_MONOID_FP32; -extern GrB_Monoid GrB_MAX_MONOID_FP64; -extern GrB_Monoid GrB_MAX_MONOID_INT8; -extern GrB_Monoid GrB_MAX_MONOID_INT16; -extern GrB_Monoid GrB_MAX_MONOID_INT32; -extern GrB_Monoid GrB_MAX_MONOID_INT64; -extern GrB_Monoid GrB_MAX_MONOID_UINT8; -extern GrB_Monoid GrB_MAX_MONOID_UINT16; -extern GrB_Monoid GrB_MAX_MONOID_UINT32; -extern GrB_Monoid GrB_MAX_MONOID_UINT64; -extern GrB_Monoid GrB_MIN_MONOID_FP32; -extern GrB_Monoid GrB_MIN_MONOID_FP64; -extern GrB_Monoid GrB_MIN_MONOID_INT8; -extern GrB_Monoid GrB_MIN_MONOID_INT16; -extern GrB_Monoid GrB_MIN_MONOID_INT32; -extern GrB_Monoid GrB_MIN_MONOID_INT64; -extern GrB_Monoid GrB_MIN_MONOID_UINT8; -extern GrB_Monoid GrB_MIN_MONOID_UINT16; -extern GrB_Monoid GrB_MIN_MONOID_UINT32; -extern GrB_Monoid GrB_MIN_MONOID_UINT64; -extern GrB_Monoid GrB_PLUS_MONOID_FP32; -extern GrB_Monoid GrB_PLUS_MONOID_FP64; -extern GrB_Monoid GrB_PLUS_MONOID_INT8; -extern GrB_Monoid GrB_PLUS_MONOID_INT16; -extern GrB_Monoid GrB_PLUS_MONOID_INT32; -extern GrB_Monoid GrB_PLUS_MONOID_INT64; -extern GrB_Monoid GrB_PLUS_MONOID_UINT8; -extern GrB_Monoid GrB_PLUS_MONOID_UINT16; -extern GrB_Monoid GrB_PLUS_MONOID_UINT32; -extern GrB_Monoid GrB_PLUS_MONOID_UINT64; -extern GrB_Monoid GrB_TIMES_MONOID_FP32; -extern GrB_Monoid GrB_TIMES_MONOID_FP64; -extern GrB_Monoid GrB_TIMES_MONOID_INT8; -extern GrB_Monoid GrB_TIMES_MONOID_INT16; -extern GrB_Monoid GrB_TIMES_MONOID_INT32; -extern GrB_Monoid GrB_TIMES_MONOID_INT64; -extern GrB_Monoid GrB_TIMES_MONOID_UINT8; -extern GrB_Monoid GrB_TIMES_MONOID_UINT16; -extern GrB_Monoid GrB_TIMES_MONOID_UINT32; -extern GrB_Monoid GrB_TIMES_MONOID_UINT64; -extern GrB_Semiring GrB_LAND_LOR_SEMIRING_BOOL; -extern GrB_Semiring GrB_LOR_LAND_SEMIRING_BOOL; -extern GrB_Semiring GrB_LXNOR_LOR_SEMIRING_BOOL; -extern GrB_Semiring GrB_LXOR_LAND_SEMIRING_BOOL; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT64; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP32; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP64; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT8; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT16; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT32; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT64; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT8; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT16; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT32; -extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT64; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP32; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP64; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT8; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT16; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT32; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT64; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT8; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT16; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT32; -extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT64; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP32; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP64; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT8; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT16; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT32; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT64; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT8; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT16; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT32; -extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT64; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP32; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP64; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT8; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT16; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT32; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT64; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT8; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT16; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT32; -extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT64; -extern GrB_Type GrB_BOOL; -extern GrB_Type GrB_FP32; -extern GrB_Type GrB_FP64; -extern GrB_Type GrB_INT8; -extern GrB_Type GrB_INT16; -extern GrB_Type GrB_INT32; -extern GrB_Type GrB_INT64; -extern GrB_Type GrB_UINT8; -extern GrB_Type GrB_UINT16; -extern GrB_Type GrB_UINT32; -extern GrB_Type GrB_UINT64; -extern GrB_UnaryOp GrB_ABS_BOOL; -extern GrB_UnaryOp GrB_ABS_FP32; -extern GrB_UnaryOp GrB_ABS_FP64; -extern GrB_UnaryOp GrB_ABS_INT8; -extern GrB_UnaryOp GrB_ABS_INT16; -extern GrB_UnaryOp GrB_ABS_INT32; -extern GrB_UnaryOp GrB_ABS_INT64; -extern GrB_UnaryOp GrB_ABS_UINT8; -extern GrB_UnaryOp GrB_ABS_UINT16; -extern GrB_UnaryOp GrB_ABS_UINT32; -extern GrB_UnaryOp GrB_ABS_UINT64; -extern GrB_UnaryOp GrB_AINV_BOOL; -extern GrB_UnaryOp GrB_AINV_FP32; -extern GrB_UnaryOp GrB_AINV_FP64; -extern GrB_UnaryOp GrB_AINV_INT8; -extern GrB_UnaryOp GrB_AINV_INT16; -extern GrB_UnaryOp GrB_AINV_INT32; -extern GrB_UnaryOp GrB_AINV_INT64; -extern GrB_UnaryOp GrB_AINV_UINT8; -extern GrB_UnaryOp GrB_AINV_UINT16; -extern GrB_UnaryOp GrB_AINV_UINT32; -extern GrB_UnaryOp GrB_AINV_UINT64; -extern GrB_UnaryOp GrB_BNOT_INT8; -extern GrB_UnaryOp GrB_BNOT_INT16; -extern GrB_UnaryOp GrB_BNOT_INT32; -extern GrB_UnaryOp GrB_BNOT_INT64; -extern GrB_UnaryOp GrB_BNOT_UINT8; -extern GrB_UnaryOp GrB_BNOT_UINT16; -extern GrB_UnaryOp GrB_BNOT_UINT32; -extern GrB_UnaryOp GrB_BNOT_UINT64; -extern GrB_UnaryOp GrB_IDENTITY_BOOL; -extern GrB_UnaryOp GrB_IDENTITY_FP32; -extern GrB_UnaryOp GrB_IDENTITY_FP64; -extern GrB_UnaryOp GrB_IDENTITY_INT8; -extern GrB_UnaryOp GrB_IDENTITY_INT16; -extern GrB_UnaryOp GrB_IDENTITY_INT32; -extern GrB_UnaryOp GrB_IDENTITY_INT64; -extern GrB_UnaryOp GrB_IDENTITY_UINT8; -extern GrB_UnaryOp GrB_IDENTITY_UINT16; -extern GrB_UnaryOp GrB_IDENTITY_UINT32; -extern GrB_UnaryOp GrB_IDENTITY_UINT64; -extern GrB_UnaryOp GrB_LNOT; -extern GrB_UnaryOp GrB_MINV_BOOL; -extern GrB_UnaryOp GrB_MINV_FP32; -extern GrB_UnaryOp GrB_MINV_FP64; -extern GrB_UnaryOp GrB_MINV_INT8; -extern GrB_UnaryOp GrB_MINV_INT16; -extern GrB_UnaryOp GrB_MINV_INT32; -extern GrB_UnaryOp GrB_MINV_INT64; -extern GrB_UnaryOp GrB_MINV_UINT8; -extern GrB_UnaryOp GrB_MINV_UINT16; -extern GrB_UnaryOp GrB_MINV_UINT32; -extern GrB_UnaryOp GrB_MINV_UINT64; - -/* GrB objects (extended) */ -extern GrB_BinaryOp GxB_ANY_BOOL; -extern GrB_BinaryOp GxB_ANY_FP32; -extern GrB_BinaryOp GxB_ANY_FP64; -extern GrB_BinaryOp GxB_ANY_INT8; -extern GrB_BinaryOp GxB_ANY_INT16; -extern GrB_BinaryOp GxB_ANY_INT32; -extern GrB_BinaryOp GxB_ANY_INT64; -extern GrB_BinaryOp GxB_ANY_UINT8; -extern GrB_BinaryOp GxB_ANY_UINT16; -extern GrB_BinaryOp GxB_ANY_UINT32; -extern GrB_BinaryOp GxB_ANY_UINT64; -extern GrB_BinaryOp GxB_ATAN2_FP32; -extern GrB_BinaryOp GxB_ATAN2_FP64; -extern GrB_BinaryOp GxB_BCLR_INT8; -extern GrB_BinaryOp GxB_BCLR_INT16; -extern GrB_BinaryOp GxB_BCLR_INT32; -extern GrB_BinaryOp GxB_BCLR_INT64; -extern GrB_BinaryOp GxB_BCLR_UINT8; -extern GrB_BinaryOp GxB_BCLR_UINT16; -extern GrB_BinaryOp GxB_BCLR_UINT32; -extern GrB_BinaryOp GxB_BCLR_UINT64; -extern GrB_BinaryOp GxB_BGET_INT8; -extern GrB_BinaryOp GxB_BGET_INT16; -extern GrB_BinaryOp GxB_BGET_INT32; -extern GrB_BinaryOp GxB_BGET_INT64; -extern GrB_BinaryOp GxB_BGET_UINT8; -extern GrB_BinaryOp GxB_BGET_UINT16; -extern GrB_BinaryOp GxB_BGET_UINT32; -extern GrB_BinaryOp GxB_BGET_UINT64; -extern GrB_BinaryOp GxB_BSET_INT8; -extern GrB_BinaryOp GxB_BSET_INT16; -extern GrB_BinaryOp GxB_BSET_INT32; -extern GrB_BinaryOp GxB_BSET_INT64; -extern GrB_BinaryOp GxB_BSET_UINT8; -extern GrB_BinaryOp GxB_BSET_UINT16; -extern GrB_BinaryOp GxB_BSET_UINT32; -extern GrB_BinaryOp GxB_BSET_UINT64; -extern GrB_BinaryOp GxB_BSHIFT_INT8; -extern GrB_BinaryOp GxB_BSHIFT_INT16; -extern GrB_BinaryOp GxB_BSHIFT_INT32; -extern GrB_BinaryOp GxB_BSHIFT_INT64; -extern GrB_BinaryOp GxB_BSHIFT_UINT8; -extern GrB_BinaryOp GxB_BSHIFT_UINT16; -extern GrB_BinaryOp GxB_BSHIFT_UINT32; -extern GrB_BinaryOp GxB_BSHIFT_UINT64; -extern GrB_BinaryOp GxB_CMPLX_FP32; -extern GrB_BinaryOp GxB_CMPLX_FP64; -extern GrB_BinaryOp GxB_COPYSIGN_FP32; -extern GrB_BinaryOp GxB_COPYSIGN_FP64; -extern GrB_BinaryOp GxB_FIRSTI1_INT32; -extern GrB_BinaryOp GxB_FIRSTI1_INT64; -extern GrB_BinaryOp GxB_FIRSTI_INT32; -extern GrB_BinaryOp GxB_FIRSTI_INT64; -extern GrB_BinaryOp GxB_FIRSTJ1_INT32; -extern GrB_BinaryOp GxB_FIRSTJ1_INT64; -extern GrB_BinaryOp GxB_FIRSTJ_INT32; -extern GrB_BinaryOp GxB_FIRSTJ_INT64; -extern GrB_BinaryOp GxB_FMOD_FP32; -extern GrB_BinaryOp GxB_FMOD_FP64; -extern GrB_BinaryOp GxB_HYPOT_FP32; -extern GrB_BinaryOp GxB_HYPOT_FP64; -extern GrB_BinaryOp GxB_ISEQ_BOOL; -extern GrB_BinaryOp GxB_ISEQ_FP32; -extern GrB_BinaryOp GxB_ISEQ_FP64; -extern GrB_BinaryOp GxB_ISEQ_INT8; -extern GrB_BinaryOp GxB_ISEQ_INT16; -extern GrB_BinaryOp GxB_ISEQ_INT32; -extern GrB_BinaryOp GxB_ISEQ_INT64; -extern GrB_BinaryOp GxB_ISEQ_UINT8; -extern GrB_BinaryOp GxB_ISEQ_UINT16; -extern GrB_BinaryOp GxB_ISEQ_UINT32; -extern GrB_BinaryOp GxB_ISEQ_UINT64; -extern GrB_BinaryOp GxB_ISGE_BOOL; -extern GrB_BinaryOp GxB_ISGE_FP32; -extern GrB_BinaryOp GxB_ISGE_FP64; -extern GrB_BinaryOp GxB_ISGE_INT8; -extern GrB_BinaryOp GxB_ISGE_INT16; -extern GrB_BinaryOp GxB_ISGE_INT32; -extern GrB_BinaryOp GxB_ISGE_INT64; -extern GrB_BinaryOp GxB_ISGE_UINT8; -extern GrB_BinaryOp GxB_ISGE_UINT16; -extern GrB_BinaryOp GxB_ISGE_UINT32; -extern GrB_BinaryOp GxB_ISGE_UINT64; -extern GrB_BinaryOp GxB_ISGT_BOOL; -extern GrB_BinaryOp GxB_ISGT_FP32; -extern GrB_BinaryOp GxB_ISGT_FP64; -extern GrB_BinaryOp GxB_ISGT_INT8; -extern GrB_BinaryOp GxB_ISGT_INT16; -extern GrB_BinaryOp GxB_ISGT_INT32; -extern GrB_BinaryOp GxB_ISGT_INT64; -extern GrB_BinaryOp GxB_ISGT_UINT8; -extern GrB_BinaryOp GxB_ISGT_UINT16; -extern GrB_BinaryOp GxB_ISGT_UINT32; -extern GrB_BinaryOp GxB_ISGT_UINT64; -extern GrB_BinaryOp GxB_ISLE_BOOL; -extern GrB_BinaryOp GxB_ISLE_FP32; -extern GrB_BinaryOp GxB_ISLE_FP64; -extern GrB_BinaryOp GxB_ISLE_INT8; -extern GrB_BinaryOp GxB_ISLE_INT16; -extern GrB_BinaryOp GxB_ISLE_INT32; -extern GrB_BinaryOp GxB_ISLE_INT64; -extern GrB_BinaryOp GxB_ISLE_UINT8; -extern GrB_BinaryOp GxB_ISLE_UINT16; -extern GrB_BinaryOp GxB_ISLE_UINT32; -extern GrB_BinaryOp GxB_ISLE_UINT64; -extern GrB_BinaryOp GxB_ISLT_BOOL; -extern GrB_BinaryOp GxB_ISLT_FP32; -extern GrB_BinaryOp GxB_ISLT_FP64; -extern GrB_BinaryOp GxB_ISLT_INT8; -extern GrB_BinaryOp GxB_ISLT_INT16; -extern GrB_BinaryOp GxB_ISLT_INT32; -extern GrB_BinaryOp GxB_ISLT_INT64; -extern GrB_BinaryOp GxB_ISLT_UINT8; -extern GrB_BinaryOp GxB_ISLT_UINT16; -extern GrB_BinaryOp GxB_ISLT_UINT32; -extern GrB_BinaryOp GxB_ISLT_UINT64; -extern GrB_BinaryOp GxB_ISNE_BOOL; -extern GrB_BinaryOp GxB_ISNE_FP32; -extern GrB_BinaryOp GxB_ISNE_FP64; -extern GrB_BinaryOp GxB_ISNE_INT8; -extern GrB_BinaryOp GxB_ISNE_INT16; -extern GrB_BinaryOp GxB_ISNE_INT32; -extern GrB_BinaryOp GxB_ISNE_INT64; -extern GrB_BinaryOp GxB_ISNE_UINT8; -extern GrB_BinaryOp GxB_ISNE_UINT16; -extern GrB_BinaryOp GxB_ISNE_UINT32; -extern GrB_BinaryOp GxB_ISNE_UINT64; -extern GrB_BinaryOp GxB_LAND_BOOL; -extern GrB_BinaryOp GxB_LAND_FP32; -extern GrB_BinaryOp GxB_LAND_FP64; -extern GrB_BinaryOp GxB_LAND_INT8; -extern GrB_BinaryOp GxB_LAND_INT16; -extern GrB_BinaryOp GxB_LAND_INT32; -extern GrB_BinaryOp GxB_LAND_INT64; -extern GrB_BinaryOp GxB_LAND_UINT8; -extern GrB_BinaryOp GxB_LAND_UINT16; -extern GrB_BinaryOp GxB_LAND_UINT32; -extern GrB_BinaryOp GxB_LAND_UINT64; -extern GrB_BinaryOp GxB_LDEXP_FP32; -extern GrB_BinaryOp GxB_LDEXP_FP64; -extern GrB_BinaryOp GxB_LOR_BOOL; -extern GrB_BinaryOp GxB_LOR_FP32; -extern GrB_BinaryOp GxB_LOR_FP64; -extern GrB_BinaryOp GxB_LOR_INT8; -extern GrB_BinaryOp GxB_LOR_INT16; -extern GrB_BinaryOp GxB_LOR_INT32; -extern GrB_BinaryOp GxB_LOR_INT64; -extern GrB_BinaryOp GxB_LOR_UINT8; -extern GrB_BinaryOp GxB_LOR_UINT16; -extern GrB_BinaryOp GxB_LOR_UINT32; -extern GrB_BinaryOp GxB_LOR_UINT64; -extern GrB_BinaryOp GxB_LXOR_BOOL; -extern GrB_BinaryOp GxB_LXOR_FP32; -extern GrB_BinaryOp GxB_LXOR_FP64; -extern GrB_BinaryOp GxB_LXOR_INT8; -extern GrB_BinaryOp GxB_LXOR_INT16; -extern GrB_BinaryOp GxB_LXOR_INT32; -extern GrB_BinaryOp GxB_LXOR_INT64; -extern GrB_BinaryOp GxB_LXOR_UINT8; -extern GrB_BinaryOp GxB_LXOR_UINT16; -extern GrB_BinaryOp GxB_LXOR_UINT32; -extern GrB_BinaryOp GxB_LXOR_UINT64; -extern GrB_BinaryOp GxB_PAIR_BOOL; -extern GrB_BinaryOp GxB_PAIR_FP32; -extern GrB_BinaryOp GxB_PAIR_FP64; -extern GrB_BinaryOp GxB_PAIR_INT8; -extern GrB_BinaryOp GxB_PAIR_INT16; -extern GrB_BinaryOp GxB_PAIR_INT32; -extern GrB_BinaryOp GxB_PAIR_INT64; -extern GrB_BinaryOp GxB_PAIR_UINT8; -extern GrB_BinaryOp GxB_PAIR_UINT16; -extern GrB_BinaryOp GxB_PAIR_UINT32; -extern GrB_BinaryOp GxB_PAIR_UINT64; -extern GrB_BinaryOp GxB_POW_BOOL; -extern GrB_BinaryOp GxB_POW_FP32; -extern GrB_BinaryOp GxB_POW_FP64; -extern GrB_BinaryOp GxB_POW_INT8; -extern GrB_BinaryOp GxB_POW_INT16; -extern GrB_BinaryOp GxB_POW_INT32; -extern GrB_BinaryOp GxB_POW_INT64; -extern GrB_BinaryOp GxB_POW_UINT8; -extern GrB_BinaryOp GxB_POW_UINT16; -extern GrB_BinaryOp GxB_POW_UINT32; -extern GrB_BinaryOp GxB_POW_UINT64; -extern GrB_BinaryOp GxB_RDIV_BOOL; -extern GrB_BinaryOp GxB_RDIV_FP32; -extern GrB_BinaryOp GxB_RDIV_FP64; -extern GrB_BinaryOp GxB_RDIV_INT8; -extern GrB_BinaryOp GxB_RDIV_INT16; -extern GrB_BinaryOp GxB_RDIV_INT32; -extern GrB_BinaryOp GxB_RDIV_INT64; -extern GrB_BinaryOp GxB_RDIV_UINT8; -extern GrB_BinaryOp GxB_RDIV_UINT16; -extern GrB_BinaryOp GxB_RDIV_UINT32; -extern GrB_BinaryOp GxB_RDIV_UINT64; -extern GrB_BinaryOp GxB_REMAINDER_FP32; -extern GrB_BinaryOp GxB_REMAINDER_FP64; -extern GrB_BinaryOp GxB_RMINUS_BOOL; -extern GrB_BinaryOp GxB_RMINUS_FP32; -extern GrB_BinaryOp GxB_RMINUS_FP64; -extern GrB_BinaryOp GxB_RMINUS_INT8; -extern GrB_BinaryOp GxB_RMINUS_INT16; -extern GrB_BinaryOp GxB_RMINUS_INT32; -extern GrB_BinaryOp GxB_RMINUS_INT64; -extern GrB_BinaryOp GxB_RMINUS_UINT8; -extern GrB_BinaryOp GxB_RMINUS_UINT16; -extern GrB_BinaryOp GxB_RMINUS_UINT32; -extern GrB_BinaryOp GxB_RMINUS_UINT64; -extern GrB_BinaryOp GxB_SECONDI1_INT32; -extern GrB_BinaryOp GxB_SECONDI1_INT64; -extern GrB_BinaryOp GxB_SECONDI_INT32; -extern GrB_BinaryOp GxB_SECONDI_INT64; -extern GrB_BinaryOp GxB_SECONDJ1_INT32; -extern GrB_BinaryOp GxB_SECONDJ1_INT64; -extern GrB_BinaryOp GxB_SECONDJ_INT32; -extern GrB_BinaryOp GxB_SECONDJ_INT64; -extern GrB_Monoid GxB_ANY_BOOL_MONOID; -extern GrB_Monoid GxB_ANY_FP32_MONOID; -extern GrB_Monoid GxB_ANY_FP64_MONOID; -extern GrB_Monoid GxB_ANY_INT8_MONOID; -extern GrB_Monoid GxB_ANY_INT16_MONOID; -extern GrB_Monoid GxB_ANY_INT32_MONOID; -extern GrB_Monoid GxB_ANY_INT64_MONOID; -extern GrB_Monoid GxB_ANY_UINT8_MONOID; -extern GrB_Monoid GxB_ANY_UINT16_MONOID; -extern GrB_Monoid GxB_ANY_UINT32_MONOID; -extern GrB_Monoid GxB_ANY_UINT64_MONOID; -extern GrB_Monoid GxB_BAND_UINT8_MONOID; -extern GrB_Monoid GxB_BAND_UINT16_MONOID; -extern GrB_Monoid GxB_BAND_UINT32_MONOID; -extern GrB_Monoid GxB_BAND_UINT64_MONOID; -extern GrB_Monoid GxB_BOR_UINT8_MONOID; -extern GrB_Monoid GxB_BOR_UINT16_MONOID; -extern GrB_Monoid GxB_BOR_UINT32_MONOID; -extern GrB_Monoid GxB_BOR_UINT64_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT8_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT16_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT32_MONOID; -extern GrB_Monoid GxB_BXNOR_UINT64_MONOID; -extern GrB_Monoid GxB_BXOR_UINT8_MONOID; -extern GrB_Monoid GxB_BXOR_UINT16_MONOID; -extern GrB_Monoid GxB_BXOR_UINT32_MONOID; -extern GrB_Monoid GxB_BXOR_UINT64_MONOID; -extern GrB_Monoid GxB_EQ_BOOL_MONOID; -extern GrB_Semiring GxB_ANY_DIV_FP32; -extern GrB_Semiring GxB_ANY_DIV_FP64; -extern GrB_Semiring GxB_ANY_DIV_INT8; -extern GrB_Semiring GxB_ANY_DIV_INT16; -extern GrB_Semiring GxB_ANY_DIV_INT32; -extern GrB_Semiring GxB_ANY_DIV_INT64; -extern GrB_Semiring GxB_ANY_DIV_UINT8; -extern GrB_Semiring GxB_ANY_DIV_UINT16; -extern GrB_Semiring GxB_ANY_DIV_UINT32; -extern GrB_Semiring GxB_ANY_DIV_UINT64; -extern GrB_Semiring GxB_ANY_EQ_BOOL; -extern GrB_Semiring GxB_ANY_EQ_FP32; -extern GrB_Semiring GxB_ANY_EQ_FP64; -extern GrB_Semiring GxB_ANY_EQ_INT8; -extern GrB_Semiring GxB_ANY_EQ_INT16; -extern GrB_Semiring GxB_ANY_EQ_INT32; -extern GrB_Semiring GxB_ANY_EQ_INT64; -extern GrB_Semiring GxB_ANY_EQ_UINT8; -extern GrB_Semiring GxB_ANY_EQ_UINT16; -extern GrB_Semiring GxB_ANY_EQ_UINT32; -extern GrB_Semiring GxB_ANY_EQ_UINT64; -extern GrB_Semiring GxB_ANY_FIRSTI1_INT32; -extern GrB_Semiring GxB_ANY_FIRSTI1_INT64; -extern GrB_Semiring GxB_ANY_FIRSTI_INT32; -extern GrB_Semiring GxB_ANY_FIRSTI_INT64; -extern GrB_Semiring GxB_ANY_FIRSTJ1_INT32; -extern GrB_Semiring GxB_ANY_FIRSTJ1_INT64; -extern GrB_Semiring GxB_ANY_FIRSTJ_INT32; -extern GrB_Semiring GxB_ANY_FIRSTJ_INT64; -extern GrB_Semiring GxB_ANY_FIRST_BOOL; -extern GrB_Semiring GxB_ANY_FIRST_FP32; -extern GrB_Semiring GxB_ANY_FIRST_FP64; -extern GrB_Semiring GxB_ANY_FIRST_INT8; -extern GrB_Semiring GxB_ANY_FIRST_INT16; -extern GrB_Semiring GxB_ANY_FIRST_INT32; -extern GrB_Semiring GxB_ANY_FIRST_INT64; -extern GrB_Semiring GxB_ANY_FIRST_UINT8; -extern GrB_Semiring GxB_ANY_FIRST_UINT16; -extern GrB_Semiring GxB_ANY_FIRST_UINT32; -extern GrB_Semiring GxB_ANY_FIRST_UINT64; -extern GrB_Semiring GxB_ANY_GE_BOOL; -extern GrB_Semiring GxB_ANY_GE_FP32; -extern GrB_Semiring GxB_ANY_GE_FP64; -extern GrB_Semiring GxB_ANY_GE_INT8; -extern GrB_Semiring GxB_ANY_GE_INT16; -extern GrB_Semiring GxB_ANY_GE_INT32; -extern GrB_Semiring GxB_ANY_GE_INT64; -extern GrB_Semiring GxB_ANY_GE_UINT8; -extern GrB_Semiring GxB_ANY_GE_UINT16; -extern GrB_Semiring GxB_ANY_GE_UINT32; -extern GrB_Semiring GxB_ANY_GE_UINT64; -extern GrB_Semiring GxB_ANY_GT_BOOL; -extern GrB_Semiring GxB_ANY_GT_FP32; -extern GrB_Semiring GxB_ANY_GT_FP64; -extern GrB_Semiring GxB_ANY_GT_INT8; -extern GrB_Semiring GxB_ANY_GT_INT16; -extern GrB_Semiring GxB_ANY_GT_INT32; -extern GrB_Semiring GxB_ANY_GT_INT64; -extern GrB_Semiring GxB_ANY_GT_UINT8; -extern GrB_Semiring GxB_ANY_GT_UINT16; -extern GrB_Semiring GxB_ANY_GT_UINT32; -extern GrB_Semiring GxB_ANY_GT_UINT64; -extern GrB_Semiring GxB_ANY_ISEQ_FP32; -extern GrB_Semiring GxB_ANY_ISEQ_FP64; -extern GrB_Semiring GxB_ANY_ISEQ_INT8; -extern GrB_Semiring GxB_ANY_ISEQ_INT16; -extern GrB_Semiring GxB_ANY_ISEQ_INT32; -extern GrB_Semiring GxB_ANY_ISEQ_INT64; -extern GrB_Semiring GxB_ANY_ISEQ_UINT8; -extern GrB_Semiring GxB_ANY_ISEQ_UINT16; -extern GrB_Semiring GxB_ANY_ISEQ_UINT32; -extern GrB_Semiring GxB_ANY_ISEQ_UINT64; -extern GrB_Semiring GxB_ANY_ISGE_FP32; -extern GrB_Semiring GxB_ANY_ISGE_FP64; -extern GrB_Semiring GxB_ANY_ISGE_INT8; -extern GrB_Semiring GxB_ANY_ISGE_INT16; -extern GrB_Semiring GxB_ANY_ISGE_INT32; -extern GrB_Semiring GxB_ANY_ISGE_INT64; -extern GrB_Semiring GxB_ANY_ISGE_UINT8; -extern GrB_Semiring GxB_ANY_ISGE_UINT16; -extern GrB_Semiring GxB_ANY_ISGE_UINT32; -extern GrB_Semiring GxB_ANY_ISGE_UINT64; -extern GrB_Semiring GxB_ANY_ISGT_FP32; -extern GrB_Semiring GxB_ANY_ISGT_FP64; -extern GrB_Semiring GxB_ANY_ISGT_INT8; -extern GrB_Semiring GxB_ANY_ISGT_INT16; -extern GrB_Semiring GxB_ANY_ISGT_INT32; -extern GrB_Semiring GxB_ANY_ISGT_INT64; -extern GrB_Semiring GxB_ANY_ISGT_UINT8; -extern GrB_Semiring GxB_ANY_ISGT_UINT16; -extern GrB_Semiring GxB_ANY_ISGT_UINT32; -extern GrB_Semiring GxB_ANY_ISGT_UINT64; -extern GrB_Semiring GxB_ANY_ISLE_FP32; -extern GrB_Semiring GxB_ANY_ISLE_FP64; -extern GrB_Semiring GxB_ANY_ISLE_INT8; -extern GrB_Semiring GxB_ANY_ISLE_INT16; -extern GrB_Semiring GxB_ANY_ISLE_INT32; -extern GrB_Semiring GxB_ANY_ISLE_INT64; -extern GrB_Semiring GxB_ANY_ISLE_UINT8; -extern GrB_Semiring GxB_ANY_ISLE_UINT16; -extern GrB_Semiring GxB_ANY_ISLE_UINT32; -extern GrB_Semiring GxB_ANY_ISLE_UINT64; -extern GrB_Semiring GxB_ANY_ISLT_FP32; -extern GrB_Semiring GxB_ANY_ISLT_FP64; -extern GrB_Semiring GxB_ANY_ISLT_INT8; -extern GrB_Semiring GxB_ANY_ISLT_INT16; -extern GrB_Semiring GxB_ANY_ISLT_INT32; -extern GrB_Semiring GxB_ANY_ISLT_INT64; -extern GrB_Semiring GxB_ANY_ISLT_UINT8; -extern GrB_Semiring GxB_ANY_ISLT_UINT16; -extern GrB_Semiring GxB_ANY_ISLT_UINT32; -extern GrB_Semiring GxB_ANY_ISLT_UINT64; -extern GrB_Semiring GxB_ANY_ISNE_FP32; -extern GrB_Semiring GxB_ANY_ISNE_FP64; -extern GrB_Semiring GxB_ANY_ISNE_INT8; -extern GrB_Semiring GxB_ANY_ISNE_INT16; -extern GrB_Semiring GxB_ANY_ISNE_INT32; -extern GrB_Semiring GxB_ANY_ISNE_INT64; -extern GrB_Semiring GxB_ANY_ISNE_UINT8; -extern GrB_Semiring GxB_ANY_ISNE_UINT16; -extern GrB_Semiring GxB_ANY_ISNE_UINT32; -extern GrB_Semiring GxB_ANY_ISNE_UINT64; -extern GrB_Semiring GxB_ANY_LAND_BOOL; -extern GrB_Semiring GxB_ANY_LAND_FP32; -extern GrB_Semiring GxB_ANY_LAND_FP64; -extern GrB_Semiring GxB_ANY_LAND_INT8; -extern GrB_Semiring GxB_ANY_LAND_INT16; -extern GrB_Semiring GxB_ANY_LAND_INT32; -extern GrB_Semiring GxB_ANY_LAND_INT64; -extern GrB_Semiring GxB_ANY_LAND_UINT8; -extern GrB_Semiring GxB_ANY_LAND_UINT16; -extern GrB_Semiring GxB_ANY_LAND_UINT32; -extern GrB_Semiring GxB_ANY_LAND_UINT64; -extern GrB_Semiring GxB_ANY_LE_BOOL; -extern GrB_Semiring GxB_ANY_LE_FP32; -extern GrB_Semiring GxB_ANY_LE_FP64; -extern GrB_Semiring GxB_ANY_LE_INT8; -extern GrB_Semiring GxB_ANY_LE_INT16; -extern GrB_Semiring GxB_ANY_LE_INT32; -extern GrB_Semiring GxB_ANY_LE_INT64; -extern GrB_Semiring GxB_ANY_LE_UINT8; -extern GrB_Semiring GxB_ANY_LE_UINT16; -extern GrB_Semiring GxB_ANY_LE_UINT32; -extern GrB_Semiring GxB_ANY_LE_UINT64; -extern GrB_Semiring GxB_ANY_LOR_BOOL; -extern GrB_Semiring GxB_ANY_LOR_FP32; -extern GrB_Semiring GxB_ANY_LOR_FP64; -extern GrB_Semiring GxB_ANY_LOR_INT8; -extern GrB_Semiring GxB_ANY_LOR_INT16; -extern GrB_Semiring GxB_ANY_LOR_INT32; -extern GrB_Semiring GxB_ANY_LOR_INT64; -extern GrB_Semiring GxB_ANY_LOR_UINT8; -extern GrB_Semiring GxB_ANY_LOR_UINT16; -extern GrB_Semiring GxB_ANY_LOR_UINT32; -extern GrB_Semiring GxB_ANY_LOR_UINT64; -extern GrB_Semiring GxB_ANY_LT_BOOL; -extern GrB_Semiring GxB_ANY_LT_FP32; -extern GrB_Semiring GxB_ANY_LT_FP64; -extern GrB_Semiring GxB_ANY_LT_INT8; -extern GrB_Semiring GxB_ANY_LT_INT16; -extern GrB_Semiring GxB_ANY_LT_INT32; -extern GrB_Semiring GxB_ANY_LT_INT64; -extern GrB_Semiring GxB_ANY_LT_UINT8; -extern GrB_Semiring GxB_ANY_LT_UINT16; -extern GrB_Semiring GxB_ANY_LT_UINT32; -extern GrB_Semiring GxB_ANY_LT_UINT64; -extern GrB_Semiring GxB_ANY_LXOR_BOOL; -extern GrB_Semiring GxB_ANY_LXOR_FP32; -extern GrB_Semiring GxB_ANY_LXOR_FP64; -extern GrB_Semiring GxB_ANY_LXOR_INT8; -extern GrB_Semiring GxB_ANY_LXOR_INT16; -extern GrB_Semiring GxB_ANY_LXOR_INT32; -extern GrB_Semiring GxB_ANY_LXOR_INT64; -extern GrB_Semiring GxB_ANY_LXOR_UINT8; -extern GrB_Semiring GxB_ANY_LXOR_UINT16; -extern GrB_Semiring GxB_ANY_LXOR_UINT32; -extern GrB_Semiring GxB_ANY_LXOR_UINT64; -extern GrB_Semiring GxB_ANY_MAX_FP32; -extern GrB_Semiring GxB_ANY_MAX_FP64; -extern GrB_Semiring GxB_ANY_MAX_INT8; -extern GrB_Semiring GxB_ANY_MAX_INT16; -extern GrB_Semiring GxB_ANY_MAX_INT32; -extern GrB_Semiring GxB_ANY_MAX_INT64; -extern GrB_Semiring GxB_ANY_MAX_UINT8; -extern GrB_Semiring GxB_ANY_MAX_UINT16; -extern GrB_Semiring GxB_ANY_MAX_UINT32; -extern GrB_Semiring GxB_ANY_MAX_UINT64; -extern GrB_Semiring GxB_ANY_MINUS_FP32; -extern GrB_Semiring GxB_ANY_MINUS_FP64; -extern GrB_Semiring GxB_ANY_MINUS_INT8; -extern GrB_Semiring GxB_ANY_MINUS_INT16; -extern GrB_Semiring GxB_ANY_MINUS_INT32; -extern GrB_Semiring GxB_ANY_MINUS_INT64; -extern GrB_Semiring GxB_ANY_MINUS_UINT8; -extern GrB_Semiring GxB_ANY_MINUS_UINT16; -extern GrB_Semiring GxB_ANY_MINUS_UINT32; -extern GrB_Semiring GxB_ANY_MINUS_UINT64; -extern GrB_Semiring GxB_ANY_MIN_FP32; -extern GrB_Semiring GxB_ANY_MIN_FP64; -extern GrB_Semiring GxB_ANY_MIN_INT8; -extern GrB_Semiring GxB_ANY_MIN_INT16; -extern GrB_Semiring GxB_ANY_MIN_INT32; -extern GrB_Semiring GxB_ANY_MIN_INT64; -extern GrB_Semiring GxB_ANY_MIN_UINT8; -extern GrB_Semiring GxB_ANY_MIN_UINT16; -extern GrB_Semiring GxB_ANY_MIN_UINT32; -extern GrB_Semiring GxB_ANY_MIN_UINT64; -extern GrB_Semiring GxB_ANY_NE_FP32; -extern GrB_Semiring GxB_ANY_NE_FP64; -extern GrB_Semiring GxB_ANY_NE_INT8; -extern GrB_Semiring GxB_ANY_NE_INT16; -extern GrB_Semiring GxB_ANY_NE_INT32; -extern GrB_Semiring GxB_ANY_NE_INT64; -extern GrB_Semiring GxB_ANY_NE_UINT8; -extern GrB_Semiring GxB_ANY_NE_UINT16; -extern GrB_Semiring GxB_ANY_NE_UINT32; -extern GrB_Semiring GxB_ANY_NE_UINT64; -extern GrB_Semiring GxB_ANY_PAIR_BOOL; -extern GrB_Semiring GxB_ANY_PAIR_FP32; -extern GrB_Semiring GxB_ANY_PAIR_FP64; -extern GrB_Semiring GxB_ANY_PAIR_INT8; -extern GrB_Semiring GxB_ANY_PAIR_INT16; -extern GrB_Semiring GxB_ANY_PAIR_INT32; -extern GrB_Semiring GxB_ANY_PAIR_INT64; -extern GrB_Semiring GxB_ANY_PAIR_UINT8; -extern GrB_Semiring GxB_ANY_PAIR_UINT16; -extern GrB_Semiring GxB_ANY_PAIR_UINT32; -extern GrB_Semiring GxB_ANY_PAIR_UINT64; -extern GrB_Semiring GxB_ANY_PLUS_FP32; -extern GrB_Semiring GxB_ANY_PLUS_FP64; -extern GrB_Semiring GxB_ANY_PLUS_INT8; -extern GrB_Semiring GxB_ANY_PLUS_INT16; -extern GrB_Semiring GxB_ANY_PLUS_INT32; -extern GrB_Semiring GxB_ANY_PLUS_INT64; -extern GrB_Semiring GxB_ANY_PLUS_UINT8; -extern GrB_Semiring GxB_ANY_PLUS_UINT16; -extern GrB_Semiring GxB_ANY_PLUS_UINT32; -extern GrB_Semiring GxB_ANY_PLUS_UINT64; -extern GrB_Semiring GxB_ANY_RDIV_FP32; -extern GrB_Semiring GxB_ANY_RDIV_FP64; -extern GrB_Semiring GxB_ANY_RDIV_INT8; -extern GrB_Semiring GxB_ANY_RDIV_INT16; -extern GrB_Semiring GxB_ANY_RDIV_INT32; -extern GrB_Semiring GxB_ANY_RDIV_INT64; -extern GrB_Semiring GxB_ANY_RDIV_UINT8; -extern GrB_Semiring GxB_ANY_RDIV_UINT16; -extern GrB_Semiring GxB_ANY_RDIV_UINT32; -extern GrB_Semiring GxB_ANY_RDIV_UINT64; -extern GrB_Semiring GxB_ANY_RMINUS_FP32; -extern GrB_Semiring GxB_ANY_RMINUS_FP64; -extern GrB_Semiring GxB_ANY_RMINUS_INT8; -extern GrB_Semiring GxB_ANY_RMINUS_INT16; -extern GrB_Semiring GxB_ANY_RMINUS_INT32; -extern GrB_Semiring GxB_ANY_RMINUS_INT64; -extern GrB_Semiring GxB_ANY_RMINUS_UINT8; -extern GrB_Semiring GxB_ANY_RMINUS_UINT16; -extern GrB_Semiring GxB_ANY_RMINUS_UINT32; -extern GrB_Semiring GxB_ANY_RMINUS_UINT64; -extern GrB_Semiring GxB_ANY_SECONDI1_INT32; -extern GrB_Semiring GxB_ANY_SECONDI1_INT64; -extern GrB_Semiring GxB_ANY_SECONDI_INT32; -extern GrB_Semiring GxB_ANY_SECONDI_INT64; -extern GrB_Semiring GxB_ANY_SECONDJ1_INT32; -extern GrB_Semiring GxB_ANY_SECONDJ1_INT64; -extern GrB_Semiring GxB_ANY_SECONDJ_INT32; -extern GrB_Semiring GxB_ANY_SECONDJ_INT64; -extern GrB_Semiring GxB_ANY_SECOND_BOOL; -extern GrB_Semiring GxB_ANY_SECOND_FP32; -extern GrB_Semiring GxB_ANY_SECOND_FP64; -extern GrB_Semiring GxB_ANY_SECOND_INT8; -extern GrB_Semiring GxB_ANY_SECOND_INT16; -extern GrB_Semiring GxB_ANY_SECOND_INT32; -extern GrB_Semiring GxB_ANY_SECOND_INT64; -extern GrB_Semiring GxB_ANY_SECOND_UINT8; -extern GrB_Semiring GxB_ANY_SECOND_UINT16; -extern GrB_Semiring GxB_ANY_SECOND_UINT32; -extern GrB_Semiring GxB_ANY_SECOND_UINT64; -extern GrB_Semiring GxB_ANY_TIMES_FP32; -extern GrB_Semiring GxB_ANY_TIMES_FP64; -extern GrB_Semiring GxB_ANY_TIMES_INT8; -extern GrB_Semiring GxB_ANY_TIMES_INT16; -extern GrB_Semiring GxB_ANY_TIMES_INT32; -extern GrB_Semiring GxB_ANY_TIMES_INT64; -extern GrB_Semiring GxB_ANY_TIMES_UINT8; -extern GrB_Semiring GxB_ANY_TIMES_UINT16; -extern GrB_Semiring GxB_ANY_TIMES_UINT32; -extern GrB_Semiring GxB_ANY_TIMES_UINT64; -extern GrB_Semiring GxB_BAND_BAND_UINT8; -extern GrB_Semiring GxB_BAND_BAND_UINT16; -extern GrB_Semiring GxB_BAND_BAND_UINT32; -extern GrB_Semiring GxB_BAND_BAND_UINT64; -extern GrB_Semiring GxB_BAND_BOR_UINT8; -extern GrB_Semiring GxB_BAND_BOR_UINT16; -extern GrB_Semiring GxB_BAND_BOR_UINT32; -extern GrB_Semiring GxB_BAND_BOR_UINT64; -extern GrB_Semiring GxB_BAND_BXNOR_UINT8; -extern GrB_Semiring GxB_BAND_BXNOR_UINT16; -extern GrB_Semiring GxB_BAND_BXNOR_UINT32; -extern GrB_Semiring GxB_BAND_BXNOR_UINT64; -extern GrB_Semiring GxB_BAND_BXOR_UINT8; -extern GrB_Semiring GxB_BAND_BXOR_UINT16; -extern GrB_Semiring GxB_BAND_BXOR_UINT32; -extern GrB_Semiring GxB_BAND_BXOR_UINT64; -extern GrB_Semiring GxB_BOR_BAND_UINT8; -extern GrB_Semiring GxB_BOR_BAND_UINT16; -extern GrB_Semiring GxB_BOR_BAND_UINT32; -extern GrB_Semiring GxB_BOR_BAND_UINT64; -extern GrB_Semiring GxB_BOR_BOR_UINT8; -extern GrB_Semiring GxB_BOR_BOR_UINT16; -extern GrB_Semiring GxB_BOR_BOR_UINT32; -extern GrB_Semiring GxB_BOR_BOR_UINT64; -extern GrB_Semiring GxB_BOR_BXNOR_UINT8; -extern GrB_Semiring GxB_BOR_BXNOR_UINT16; -extern GrB_Semiring GxB_BOR_BXNOR_UINT32; -extern GrB_Semiring GxB_BOR_BXNOR_UINT64; -extern GrB_Semiring GxB_BOR_BXOR_UINT8; -extern GrB_Semiring GxB_BOR_BXOR_UINT16; -extern GrB_Semiring GxB_BOR_BXOR_UINT32; -extern GrB_Semiring GxB_BOR_BXOR_UINT64; -extern GrB_Semiring GxB_BXNOR_BAND_UINT8; -extern GrB_Semiring GxB_BXNOR_BAND_UINT16; -extern GrB_Semiring GxB_BXNOR_BAND_UINT32; -extern GrB_Semiring GxB_BXNOR_BAND_UINT64; -extern GrB_Semiring GxB_BXNOR_BOR_UINT8; -extern GrB_Semiring GxB_BXNOR_BOR_UINT16; -extern GrB_Semiring GxB_BXNOR_BOR_UINT32; -extern GrB_Semiring GxB_BXNOR_BOR_UINT64; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT8; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT16; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT32; -extern GrB_Semiring GxB_BXNOR_BXNOR_UINT64; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT8; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT16; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT32; -extern GrB_Semiring GxB_BXNOR_BXOR_UINT64; -extern GrB_Semiring GxB_BXOR_BAND_UINT8; -extern GrB_Semiring GxB_BXOR_BAND_UINT16; -extern GrB_Semiring GxB_BXOR_BAND_UINT32; -extern GrB_Semiring GxB_BXOR_BAND_UINT64; -extern GrB_Semiring GxB_BXOR_BOR_UINT8; -extern GrB_Semiring GxB_BXOR_BOR_UINT16; -extern GrB_Semiring GxB_BXOR_BOR_UINT32; -extern GrB_Semiring GxB_BXOR_BOR_UINT64; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT8; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT16; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT32; -extern GrB_Semiring GxB_BXOR_BXNOR_UINT64; -extern GrB_Semiring GxB_BXOR_BXOR_UINT8; -extern GrB_Semiring GxB_BXOR_BXOR_UINT16; -extern GrB_Semiring GxB_BXOR_BXOR_UINT32; -extern GrB_Semiring GxB_BXOR_BXOR_UINT64; -extern GrB_Semiring GxB_EQ_EQ_BOOL; -extern GrB_Semiring GxB_EQ_EQ_FP32; -extern GrB_Semiring GxB_EQ_EQ_FP64; -extern GrB_Semiring GxB_EQ_EQ_INT8; -extern GrB_Semiring GxB_EQ_EQ_INT16; -extern GrB_Semiring GxB_EQ_EQ_INT32; -extern GrB_Semiring GxB_EQ_EQ_INT64; -extern GrB_Semiring GxB_EQ_EQ_UINT8; -extern GrB_Semiring GxB_EQ_EQ_UINT16; -extern GrB_Semiring GxB_EQ_EQ_UINT32; -extern GrB_Semiring GxB_EQ_EQ_UINT64; -extern GrB_Semiring GxB_EQ_FIRST_BOOL; -extern GrB_Semiring GxB_EQ_GE_BOOL; -extern GrB_Semiring GxB_EQ_GE_FP32; -extern GrB_Semiring GxB_EQ_GE_FP64; -extern GrB_Semiring GxB_EQ_GE_INT8; -extern GrB_Semiring GxB_EQ_GE_INT16; -extern GrB_Semiring GxB_EQ_GE_INT32; -extern GrB_Semiring GxB_EQ_GE_INT64; -extern GrB_Semiring GxB_EQ_GE_UINT8; -extern GrB_Semiring GxB_EQ_GE_UINT16; -extern GrB_Semiring GxB_EQ_GE_UINT32; -extern GrB_Semiring GxB_EQ_GE_UINT64; -extern GrB_Semiring GxB_EQ_GT_BOOL; -extern GrB_Semiring GxB_EQ_GT_FP32; -extern GrB_Semiring GxB_EQ_GT_FP64; -extern GrB_Semiring GxB_EQ_GT_INT8; -extern GrB_Semiring GxB_EQ_GT_INT16; -extern GrB_Semiring GxB_EQ_GT_INT32; -extern GrB_Semiring GxB_EQ_GT_INT64; -extern GrB_Semiring GxB_EQ_GT_UINT8; -extern GrB_Semiring GxB_EQ_GT_UINT16; -extern GrB_Semiring GxB_EQ_GT_UINT32; -extern GrB_Semiring GxB_EQ_GT_UINT64; -extern GrB_Semiring GxB_EQ_LAND_BOOL; -extern GrB_Semiring GxB_EQ_LE_BOOL; -extern GrB_Semiring GxB_EQ_LE_FP32; -extern GrB_Semiring GxB_EQ_LE_FP64; -extern GrB_Semiring GxB_EQ_LE_INT8; -extern GrB_Semiring GxB_EQ_LE_INT16; -extern GrB_Semiring GxB_EQ_LE_INT32; -extern GrB_Semiring GxB_EQ_LE_INT64; -extern GrB_Semiring GxB_EQ_LE_UINT8; -extern GrB_Semiring GxB_EQ_LE_UINT16; -extern GrB_Semiring GxB_EQ_LE_UINT32; -extern GrB_Semiring GxB_EQ_LE_UINT64; -extern GrB_Semiring GxB_EQ_LOR_BOOL; -extern GrB_Semiring GxB_EQ_LT_BOOL; -extern GrB_Semiring GxB_EQ_LT_FP32; -extern GrB_Semiring GxB_EQ_LT_FP64; -extern GrB_Semiring GxB_EQ_LT_INT8; -extern GrB_Semiring GxB_EQ_LT_INT16; -extern GrB_Semiring GxB_EQ_LT_INT32; -extern GrB_Semiring GxB_EQ_LT_INT64; -extern GrB_Semiring GxB_EQ_LT_UINT8; -extern GrB_Semiring GxB_EQ_LT_UINT16; -extern GrB_Semiring GxB_EQ_LT_UINT32; -extern GrB_Semiring GxB_EQ_LT_UINT64; -extern GrB_Semiring GxB_EQ_LXOR_BOOL; -extern GrB_Semiring GxB_EQ_NE_FP32; -extern GrB_Semiring GxB_EQ_NE_FP64; -extern GrB_Semiring GxB_EQ_NE_INT8; -extern GrB_Semiring GxB_EQ_NE_INT16; -extern GrB_Semiring GxB_EQ_NE_INT32; -extern GrB_Semiring GxB_EQ_NE_INT64; -extern GrB_Semiring GxB_EQ_NE_UINT8; -extern GrB_Semiring GxB_EQ_NE_UINT16; -extern GrB_Semiring GxB_EQ_NE_UINT32; -extern GrB_Semiring GxB_EQ_NE_UINT64; -extern GrB_Semiring GxB_EQ_PAIR_BOOL; -extern GrB_Semiring GxB_EQ_SECOND_BOOL; -extern GrB_Semiring GxB_LAND_EQ_BOOL; -extern GrB_Semiring GxB_LAND_EQ_FP32; -extern GrB_Semiring GxB_LAND_EQ_FP64; -extern GrB_Semiring GxB_LAND_EQ_INT8; -extern GrB_Semiring GxB_LAND_EQ_INT16; -extern GrB_Semiring GxB_LAND_EQ_INT32; -extern GrB_Semiring GxB_LAND_EQ_INT64; -extern GrB_Semiring GxB_LAND_EQ_UINT8; -extern GrB_Semiring GxB_LAND_EQ_UINT16; -extern GrB_Semiring GxB_LAND_EQ_UINT32; -extern GrB_Semiring GxB_LAND_EQ_UINT64; -extern GrB_Semiring GxB_LAND_FIRST_BOOL; -extern GrB_Semiring GxB_LAND_GE_BOOL; -extern GrB_Semiring GxB_LAND_GE_FP32; -extern GrB_Semiring GxB_LAND_GE_FP64; -extern GrB_Semiring GxB_LAND_GE_INT8; -extern GrB_Semiring GxB_LAND_GE_INT16; -extern GrB_Semiring GxB_LAND_GE_INT32; -extern GrB_Semiring GxB_LAND_GE_INT64; -extern GrB_Semiring GxB_LAND_GE_UINT8; -extern GrB_Semiring GxB_LAND_GE_UINT16; -extern GrB_Semiring GxB_LAND_GE_UINT32; -extern GrB_Semiring GxB_LAND_GE_UINT64; -extern GrB_Semiring GxB_LAND_GT_BOOL; -extern GrB_Semiring GxB_LAND_GT_FP32; -extern GrB_Semiring GxB_LAND_GT_FP64; -extern GrB_Semiring GxB_LAND_GT_INT8; -extern GrB_Semiring GxB_LAND_GT_INT16; -extern GrB_Semiring GxB_LAND_GT_INT32; -extern GrB_Semiring GxB_LAND_GT_INT64; -extern GrB_Semiring GxB_LAND_GT_UINT8; -extern GrB_Semiring GxB_LAND_GT_UINT16; -extern GrB_Semiring GxB_LAND_GT_UINT32; -extern GrB_Semiring GxB_LAND_GT_UINT64; -extern GrB_Semiring GxB_LAND_LAND_BOOL; -extern GrB_Semiring GxB_LAND_LE_BOOL; -extern GrB_Semiring GxB_LAND_LE_FP32; -extern GrB_Semiring GxB_LAND_LE_FP64; -extern GrB_Semiring GxB_LAND_LE_INT8; -extern GrB_Semiring GxB_LAND_LE_INT16; -extern GrB_Semiring GxB_LAND_LE_INT32; -extern GrB_Semiring GxB_LAND_LE_INT64; -extern GrB_Semiring GxB_LAND_LE_UINT8; -extern GrB_Semiring GxB_LAND_LE_UINT16; -extern GrB_Semiring GxB_LAND_LE_UINT32; -extern GrB_Semiring GxB_LAND_LE_UINT64; -extern GrB_Semiring GxB_LAND_LT_BOOL; -extern GrB_Semiring GxB_LAND_LT_FP32; -extern GrB_Semiring GxB_LAND_LT_FP64; -extern GrB_Semiring GxB_LAND_LT_INT8; -extern GrB_Semiring GxB_LAND_LT_INT16; -extern GrB_Semiring GxB_LAND_LT_INT32; -extern GrB_Semiring GxB_LAND_LT_INT64; -extern GrB_Semiring GxB_LAND_LT_UINT8; -extern GrB_Semiring GxB_LAND_LT_UINT16; -extern GrB_Semiring GxB_LAND_LT_UINT32; -extern GrB_Semiring GxB_LAND_LT_UINT64; -extern GrB_Semiring GxB_LAND_LXOR_BOOL; -extern GrB_Semiring GxB_LAND_NE_FP32; -extern GrB_Semiring GxB_LAND_NE_FP64; -extern GrB_Semiring GxB_LAND_NE_INT8; -extern GrB_Semiring GxB_LAND_NE_INT16; -extern GrB_Semiring GxB_LAND_NE_INT32; -extern GrB_Semiring GxB_LAND_NE_INT64; -extern GrB_Semiring GxB_LAND_NE_UINT8; -extern GrB_Semiring GxB_LAND_NE_UINT16; -extern GrB_Semiring GxB_LAND_NE_UINT32; -extern GrB_Semiring GxB_LAND_NE_UINT64; -extern GrB_Semiring GxB_LAND_PAIR_BOOL; -extern GrB_Semiring GxB_LAND_SECOND_BOOL; -extern GrB_Semiring GxB_LOR_EQ_BOOL; -extern GrB_Semiring GxB_LOR_EQ_FP32; -extern GrB_Semiring GxB_LOR_EQ_FP64; -extern GrB_Semiring GxB_LOR_EQ_INT8; -extern GrB_Semiring GxB_LOR_EQ_INT16; -extern GrB_Semiring GxB_LOR_EQ_INT32; -extern GrB_Semiring GxB_LOR_EQ_INT64; -extern GrB_Semiring GxB_LOR_EQ_UINT8; -extern GrB_Semiring GxB_LOR_EQ_UINT16; -extern GrB_Semiring GxB_LOR_EQ_UINT32; -extern GrB_Semiring GxB_LOR_EQ_UINT64; -extern GrB_Semiring GxB_LOR_FIRST_BOOL; -extern GrB_Semiring GxB_LOR_GE_BOOL; -extern GrB_Semiring GxB_LOR_GE_FP32; -extern GrB_Semiring GxB_LOR_GE_FP64; -extern GrB_Semiring GxB_LOR_GE_INT8; -extern GrB_Semiring GxB_LOR_GE_INT16; -extern GrB_Semiring GxB_LOR_GE_INT32; -extern GrB_Semiring GxB_LOR_GE_INT64; -extern GrB_Semiring GxB_LOR_GE_UINT8; -extern GrB_Semiring GxB_LOR_GE_UINT16; -extern GrB_Semiring GxB_LOR_GE_UINT32; -extern GrB_Semiring GxB_LOR_GE_UINT64; -extern GrB_Semiring GxB_LOR_GT_BOOL; -extern GrB_Semiring GxB_LOR_GT_FP32; -extern GrB_Semiring GxB_LOR_GT_FP64; -extern GrB_Semiring GxB_LOR_GT_INT8; -extern GrB_Semiring GxB_LOR_GT_INT16; -extern GrB_Semiring GxB_LOR_GT_INT32; -extern GrB_Semiring GxB_LOR_GT_INT64; -extern GrB_Semiring GxB_LOR_GT_UINT8; -extern GrB_Semiring GxB_LOR_GT_UINT16; -extern GrB_Semiring GxB_LOR_GT_UINT32; -extern GrB_Semiring GxB_LOR_GT_UINT64; -extern GrB_Semiring GxB_LOR_LE_BOOL; -extern GrB_Semiring GxB_LOR_LE_FP32; -extern GrB_Semiring GxB_LOR_LE_FP64; -extern GrB_Semiring GxB_LOR_LE_INT8; -extern GrB_Semiring GxB_LOR_LE_INT16; -extern GrB_Semiring GxB_LOR_LE_INT32; -extern GrB_Semiring GxB_LOR_LE_INT64; -extern GrB_Semiring GxB_LOR_LE_UINT8; -extern GrB_Semiring GxB_LOR_LE_UINT16; -extern GrB_Semiring GxB_LOR_LE_UINT32; -extern GrB_Semiring GxB_LOR_LE_UINT64; -extern GrB_Semiring GxB_LOR_LOR_BOOL; -extern GrB_Semiring GxB_LOR_LT_BOOL; -extern GrB_Semiring GxB_LOR_LT_FP32; -extern GrB_Semiring GxB_LOR_LT_FP64; -extern GrB_Semiring GxB_LOR_LT_INT8; -extern GrB_Semiring GxB_LOR_LT_INT16; -extern GrB_Semiring GxB_LOR_LT_INT32; -extern GrB_Semiring GxB_LOR_LT_INT64; -extern GrB_Semiring GxB_LOR_LT_UINT8; -extern GrB_Semiring GxB_LOR_LT_UINT16; -extern GrB_Semiring GxB_LOR_LT_UINT32; -extern GrB_Semiring GxB_LOR_LT_UINT64; -extern GrB_Semiring GxB_LOR_LXOR_BOOL; -extern GrB_Semiring GxB_LOR_NE_FP32; -extern GrB_Semiring GxB_LOR_NE_FP64; -extern GrB_Semiring GxB_LOR_NE_INT8; -extern GrB_Semiring GxB_LOR_NE_INT16; -extern GrB_Semiring GxB_LOR_NE_INT32; -extern GrB_Semiring GxB_LOR_NE_INT64; -extern GrB_Semiring GxB_LOR_NE_UINT8; -extern GrB_Semiring GxB_LOR_NE_UINT16; -extern GrB_Semiring GxB_LOR_NE_UINT32; -extern GrB_Semiring GxB_LOR_NE_UINT64; -extern GrB_Semiring GxB_LOR_PAIR_BOOL; -extern GrB_Semiring GxB_LOR_SECOND_BOOL; -extern GrB_Semiring GxB_LXOR_EQ_BOOL; -extern GrB_Semiring GxB_LXOR_EQ_FP32; -extern GrB_Semiring GxB_LXOR_EQ_FP64; -extern GrB_Semiring GxB_LXOR_EQ_INT8; -extern GrB_Semiring GxB_LXOR_EQ_INT16; -extern GrB_Semiring GxB_LXOR_EQ_INT32; -extern GrB_Semiring GxB_LXOR_EQ_INT64; -extern GrB_Semiring GxB_LXOR_EQ_UINT8; -extern GrB_Semiring GxB_LXOR_EQ_UINT16; -extern GrB_Semiring GxB_LXOR_EQ_UINT32; -extern GrB_Semiring GxB_LXOR_EQ_UINT64; -extern GrB_Semiring GxB_LXOR_FIRST_BOOL; -extern GrB_Semiring GxB_LXOR_GE_BOOL; -extern GrB_Semiring GxB_LXOR_GE_FP32; -extern GrB_Semiring GxB_LXOR_GE_FP64; -extern GrB_Semiring GxB_LXOR_GE_INT8; -extern GrB_Semiring GxB_LXOR_GE_INT16; -extern GrB_Semiring GxB_LXOR_GE_INT32; -extern GrB_Semiring GxB_LXOR_GE_INT64; -extern GrB_Semiring GxB_LXOR_GE_UINT8; -extern GrB_Semiring GxB_LXOR_GE_UINT16; -extern GrB_Semiring GxB_LXOR_GE_UINT32; -extern GrB_Semiring GxB_LXOR_GE_UINT64; -extern GrB_Semiring GxB_LXOR_GT_BOOL; -extern GrB_Semiring GxB_LXOR_GT_FP32; -extern GrB_Semiring GxB_LXOR_GT_FP64; -extern GrB_Semiring GxB_LXOR_GT_INT8; -extern GrB_Semiring GxB_LXOR_GT_INT16; -extern GrB_Semiring GxB_LXOR_GT_INT32; -extern GrB_Semiring GxB_LXOR_GT_INT64; -extern GrB_Semiring GxB_LXOR_GT_UINT8; -extern GrB_Semiring GxB_LXOR_GT_UINT16; -extern GrB_Semiring GxB_LXOR_GT_UINT32; -extern GrB_Semiring GxB_LXOR_GT_UINT64; -extern GrB_Semiring GxB_LXOR_LE_BOOL; -extern GrB_Semiring GxB_LXOR_LE_FP32; -extern GrB_Semiring GxB_LXOR_LE_FP64; -extern GrB_Semiring GxB_LXOR_LE_INT8; -extern GrB_Semiring GxB_LXOR_LE_INT16; -extern GrB_Semiring GxB_LXOR_LE_INT32; -extern GrB_Semiring GxB_LXOR_LE_INT64; -extern GrB_Semiring GxB_LXOR_LE_UINT8; -extern GrB_Semiring GxB_LXOR_LE_UINT16; -extern GrB_Semiring GxB_LXOR_LE_UINT32; -extern GrB_Semiring GxB_LXOR_LE_UINT64; -extern GrB_Semiring GxB_LXOR_LOR_BOOL; -extern GrB_Semiring GxB_LXOR_LT_BOOL; -extern GrB_Semiring GxB_LXOR_LT_FP32; -extern GrB_Semiring GxB_LXOR_LT_FP64; -extern GrB_Semiring GxB_LXOR_LT_INT8; -extern GrB_Semiring GxB_LXOR_LT_INT16; -extern GrB_Semiring GxB_LXOR_LT_INT32; -extern GrB_Semiring GxB_LXOR_LT_INT64; -extern GrB_Semiring GxB_LXOR_LT_UINT8; -extern GrB_Semiring GxB_LXOR_LT_UINT16; -extern GrB_Semiring GxB_LXOR_LT_UINT32; -extern GrB_Semiring GxB_LXOR_LT_UINT64; -extern GrB_Semiring GxB_LXOR_LXOR_BOOL; -extern GrB_Semiring GxB_LXOR_NE_FP32; -extern GrB_Semiring GxB_LXOR_NE_FP64; -extern GrB_Semiring GxB_LXOR_NE_INT8; -extern GrB_Semiring GxB_LXOR_NE_INT16; -extern GrB_Semiring GxB_LXOR_NE_INT32; -extern GrB_Semiring GxB_LXOR_NE_INT64; -extern GrB_Semiring GxB_LXOR_NE_UINT8; -extern GrB_Semiring GxB_LXOR_NE_UINT16; -extern GrB_Semiring GxB_LXOR_NE_UINT32; -extern GrB_Semiring GxB_LXOR_NE_UINT64; -extern GrB_Semiring GxB_LXOR_PAIR_BOOL; -extern GrB_Semiring GxB_LXOR_SECOND_BOOL; -extern GrB_Semiring GxB_MAX_DIV_FP32; -extern GrB_Semiring GxB_MAX_DIV_FP64; -extern GrB_Semiring GxB_MAX_DIV_INT8; -extern GrB_Semiring GxB_MAX_DIV_INT16; -extern GrB_Semiring GxB_MAX_DIV_INT32; -extern GrB_Semiring GxB_MAX_DIV_INT64; -extern GrB_Semiring GxB_MAX_DIV_UINT8; -extern GrB_Semiring GxB_MAX_DIV_UINT16; -extern GrB_Semiring GxB_MAX_DIV_UINT32; -extern GrB_Semiring GxB_MAX_DIV_UINT64; -extern GrB_Semiring GxB_MAX_FIRSTI1_INT32; -extern GrB_Semiring GxB_MAX_FIRSTI1_INT64; -extern GrB_Semiring GxB_MAX_FIRSTI_INT32; -extern GrB_Semiring GxB_MAX_FIRSTI_INT64; -extern GrB_Semiring GxB_MAX_FIRSTJ1_INT32; -extern GrB_Semiring GxB_MAX_FIRSTJ1_INT64; -extern GrB_Semiring GxB_MAX_FIRSTJ_INT32; -extern GrB_Semiring GxB_MAX_FIRSTJ_INT64; -extern GrB_Semiring GxB_MAX_ISEQ_FP32; -extern GrB_Semiring GxB_MAX_ISEQ_FP64; -extern GrB_Semiring GxB_MAX_ISEQ_INT8; -extern GrB_Semiring GxB_MAX_ISEQ_INT16; -extern GrB_Semiring GxB_MAX_ISEQ_INT32; -extern GrB_Semiring GxB_MAX_ISEQ_INT64; -extern GrB_Semiring GxB_MAX_ISEQ_UINT8; -extern GrB_Semiring GxB_MAX_ISEQ_UINT16; -extern GrB_Semiring GxB_MAX_ISEQ_UINT32; -extern GrB_Semiring GxB_MAX_ISEQ_UINT64; -extern GrB_Semiring GxB_MAX_ISGE_FP32; -extern GrB_Semiring GxB_MAX_ISGE_FP64; -extern GrB_Semiring GxB_MAX_ISGE_INT8; -extern GrB_Semiring GxB_MAX_ISGE_INT16; -extern GrB_Semiring GxB_MAX_ISGE_INT32; -extern GrB_Semiring GxB_MAX_ISGE_INT64; -extern GrB_Semiring GxB_MAX_ISGE_UINT8; -extern GrB_Semiring GxB_MAX_ISGE_UINT16; -extern GrB_Semiring GxB_MAX_ISGE_UINT32; -extern GrB_Semiring GxB_MAX_ISGE_UINT64; -extern GrB_Semiring GxB_MAX_ISGT_FP32; -extern GrB_Semiring GxB_MAX_ISGT_FP64; -extern GrB_Semiring GxB_MAX_ISGT_INT8; -extern GrB_Semiring GxB_MAX_ISGT_INT16; -extern GrB_Semiring GxB_MAX_ISGT_INT32; -extern GrB_Semiring GxB_MAX_ISGT_INT64; -extern GrB_Semiring GxB_MAX_ISGT_UINT8; -extern GrB_Semiring GxB_MAX_ISGT_UINT16; -extern GrB_Semiring GxB_MAX_ISGT_UINT32; -extern GrB_Semiring GxB_MAX_ISGT_UINT64; -extern GrB_Semiring GxB_MAX_ISLE_FP32; -extern GrB_Semiring GxB_MAX_ISLE_FP64; -extern GrB_Semiring GxB_MAX_ISLE_INT8; -extern GrB_Semiring GxB_MAX_ISLE_INT16; -extern GrB_Semiring GxB_MAX_ISLE_INT32; -extern GrB_Semiring GxB_MAX_ISLE_INT64; -extern GrB_Semiring GxB_MAX_ISLE_UINT8; -extern GrB_Semiring GxB_MAX_ISLE_UINT16; -extern GrB_Semiring GxB_MAX_ISLE_UINT32; -extern GrB_Semiring GxB_MAX_ISLE_UINT64; -extern GrB_Semiring GxB_MAX_ISLT_FP32; -extern GrB_Semiring GxB_MAX_ISLT_FP64; -extern GrB_Semiring GxB_MAX_ISLT_INT8; -extern GrB_Semiring GxB_MAX_ISLT_INT16; -extern GrB_Semiring GxB_MAX_ISLT_INT32; -extern GrB_Semiring GxB_MAX_ISLT_INT64; -extern GrB_Semiring GxB_MAX_ISLT_UINT8; -extern GrB_Semiring GxB_MAX_ISLT_UINT16; -extern GrB_Semiring GxB_MAX_ISLT_UINT32; -extern GrB_Semiring GxB_MAX_ISLT_UINT64; -extern GrB_Semiring GxB_MAX_ISNE_FP32; -extern GrB_Semiring GxB_MAX_ISNE_FP64; -extern GrB_Semiring GxB_MAX_ISNE_INT8; -extern GrB_Semiring GxB_MAX_ISNE_INT16; -extern GrB_Semiring GxB_MAX_ISNE_INT32; -extern GrB_Semiring GxB_MAX_ISNE_INT64; -extern GrB_Semiring GxB_MAX_ISNE_UINT8; -extern GrB_Semiring GxB_MAX_ISNE_UINT16; -extern GrB_Semiring GxB_MAX_ISNE_UINT32; -extern GrB_Semiring GxB_MAX_ISNE_UINT64; -extern GrB_Semiring GxB_MAX_LAND_FP32; -extern GrB_Semiring GxB_MAX_LAND_FP64; -extern GrB_Semiring GxB_MAX_LAND_INT8; -extern GrB_Semiring GxB_MAX_LAND_INT16; -extern GrB_Semiring GxB_MAX_LAND_INT32; -extern GrB_Semiring GxB_MAX_LAND_INT64; -extern GrB_Semiring GxB_MAX_LAND_UINT8; -extern GrB_Semiring GxB_MAX_LAND_UINT16; -extern GrB_Semiring GxB_MAX_LAND_UINT32; -extern GrB_Semiring GxB_MAX_LAND_UINT64; -extern GrB_Semiring GxB_MAX_LOR_FP32; -extern GrB_Semiring GxB_MAX_LOR_FP64; -extern GrB_Semiring GxB_MAX_LOR_INT8; -extern GrB_Semiring GxB_MAX_LOR_INT16; -extern GrB_Semiring GxB_MAX_LOR_INT32; -extern GrB_Semiring GxB_MAX_LOR_INT64; -extern GrB_Semiring GxB_MAX_LOR_UINT8; -extern GrB_Semiring GxB_MAX_LOR_UINT16; -extern GrB_Semiring GxB_MAX_LOR_UINT32; -extern GrB_Semiring GxB_MAX_LOR_UINT64; -extern GrB_Semiring GxB_MAX_LXOR_FP32; -extern GrB_Semiring GxB_MAX_LXOR_FP64; -extern GrB_Semiring GxB_MAX_LXOR_INT8; -extern GrB_Semiring GxB_MAX_LXOR_INT16; -extern GrB_Semiring GxB_MAX_LXOR_INT32; -extern GrB_Semiring GxB_MAX_LXOR_INT64; -extern GrB_Semiring GxB_MAX_LXOR_UINT8; -extern GrB_Semiring GxB_MAX_LXOR_UINT16; -extern GrB_Semiring GxB_MAX_LXOR_UINT32; -extern GrB_Semiring GxB_MAX_LXOR_UINT64; -extern GrB_Semiring GxB_MAX_MAX_FP32; -extern GrB_Semiring GxB_MAX_MAX_FP64; -extern GrB_Semiring GxB_MAX_MAX_INT8; -extern GrB_Semiring GxB_MAX_MAX_INT16; -extern GrB_Semiring GxB_MAX_MAX_INT32; -extern GrB_Semiring GxB_MAX_MAX_INT64; -extern GrB_Semiring GxB_MAX_MAX_UINT8; -extern GrB_Semiring GxB_MAX_MAX_UINT16; -extern GrB_Semiring GxB_MAX_MAX_UINT32; -extern GrB_Semiring GxB_MAX_MAX_UINT64; -extern GrB_Semiring GxB_MAX_MINUS_FP32; -extern GrB_Semiring GxB_MAX_MINUS_FP64; -extern GrB_Semiring GxB_MAX_MINUS_INT8; -extern GrB_Semiring GxB_MAX_MINUS_INT16; -extern GrB_Semiring GxB_MAX_MINUS_INT32; -extern GrB_Semiring GxB_MAX_MINUS_INT64; -extern GrB_Semiring GxB_MAX_MINUS_UINT8; -extern GrB_Semiring GxB_MAX_MINUS_UINT16; -extern GrB_Semiring GxB_MAX_MINUS_UINT32; -extern GrB_Semiring GxB_MAX_MINUS_UINT64; -extern GrB_Semiring GxB_MAX_PAIR_FP32; -extern GrB_Semiring GxB_MAX_PAIR_FP64; -extern GrB_Semiring GxB_MAX_PAIR_INT8; -extern GrB_Semiring GxB_MAX_PAIR_INT16; -extern GrB_Semiring GxB_MAX_PAIR_INT32; -extern GrB_Semiring GxB_MAX_PAIR_INT64; -extern GrB_Semiring GxB_MAX_PAIR_UINT8; -extern GrB_Semiring GxB_MAX_PAIR_UINT16; -extern GrB_Semiring GxB_MAX_PAIR_UINT32; -extern GrB_Semiring GxB_MAX_PAIR_UINT64; -extern GrB_Semiring GxB_MAX_RDIV_FP32; -extern GrB_Semiring GxB_MAX_RDIV_FP64; -extern GrB_Semiring GxB_MAX_RDIV_INT8; -extern GrB_Semiring GxB_MAX_RDIV_INT16; -extern GrB_Semiring GxB_MAX_RDIV_INT32; -extern GrB_Semiring GxB_MAX_RDIV_INT64; -extern GrB_Semiring GxB_MAX_RDIV_UINT8; -extern GrB_Semiring GxB_MAX_RDIV_UINT16; -extern GrB_Semiring GxB_MAX_RDIV_UINT32; -extern GrB_Semiring GxB_MAX_RDIV_UINT64; -extern GrB_Semiring GxB_MAX_RMINUS_FP32; -extern GrB_Semiring GxB_MAX_RMINUS_FP64; -extern GrB_Semiring GxB_MAX_RMINUS_INT8; -extern GrB_Semiring GxB_MAX_RMINUS_INT16; -extern GrB_Semiring GxB_MAX_RMINUS_INT32; -extern GrB_Semiring GxB_MAX_RMINUS_INT64; -extern GrB_Semiring GxB_MAX_RMINUS_UINT8; -extern GrB_Semiring GxB_MAX_RMINUS_UINT16; -extern GrB_Semiring GxB_MAX_RMINUS_UINT32; -extern GrB_Semiring GxB_MAX_RMINUS_UINT64; -extern GrB_Semiring GxB_MAX_SECONDI1_INT32; -extern GrB_Semiring GxB_MAX_SECONDI1_INT64; -extern GrB_Semiring GxB_MAX_SECONDI_INT32; -extern GrB_Semiring GxB_MAX_SECONDI_INT64; -extern GrB_Semiring GxB_MAX_SECONDJ1_INT32; -extern GrB_Semiring GxB_MAX_SECONDJ1_INT64; -extern GrB_Semiring GxB_MAX_SECONDJ_INT32; -extern GrB_Semiring GxB_MAX_SECONDJ_INT64; -extern GrB_Semiring GxB_MIN_DIV_FP32; -extern GrB_Semiring GxB_MIN_DIV_FP64; -extern GrB_Semiring GxB_MIN_DIV_INT8; -extern GrB_Semiring GxB_MIN_DIV_INT16; -extern GrB_Semiring GxB_MIN_DIV_INT32; -extern GrB_Semiring GxB_MIN_DIV_INT64; -extern GrB_Semiring GxB_MIN_DIV_UINT8; -extern GrB_Semiring GxB_MIN_DIV_UINT16; -extern GrB_Semiring GxB_MIN_DIV_UINT32; -extern GrB_Semiring GxB_MIN_DIV_UINT64; -extern GrB_Semiring GxB_MIN_FIRSTI1_INT32; -extern GrB_Semiring GxB_MIN_FIRSTI1_INT64; -extern GrB_Semiring GxB_MIN_FIRSTI_INT32; -extern GrB_Semiring GxB_MIN_FIRSTI_INT64; -extern GrB_Semiring GxB_MIN_FIRSTJ1_INT32; -extern GrB_Semiring GxB_MIN_FIRSTJ1_INT64; -extern GrB_Semiring GxB_MIN_FIRSTJ_INT32; -extern GrB_Semiring GxB_MIN_FIRSTJ_INT64; -extern GrB_Semiring GxB_MIN_ISEQ_FP32; -extern GrB_Semiring GxB_MIN_ISEQ_FP64; -extern GrB_Semiring GxB_MIN_ISEQ_INT8; -extern GrB_Semiring GxB_MIN_ISEQ_INT16; -extern GrB_Semiring GxB_MIN_ISEQ_INT32; -extern GrB_Semiring GxB_MIN_ISEQ_INT64; -extern GrB_Semiring GxB_MIN_ISEQ_UINT8; -extern GrB_Semiring GxB_MIN_ISEQ_UINT16; -extern GrB_Semiring GxB_MIN_ISEQ_UINT32; -extern GrB_Semiring GxB_MIN_ISEQ_UINT64; -extern GrB_Semiring GxB_MIN_ISGE_FP32; -extern GrB_Semiring GxB_MIN_ISGE_FP64; -extern GrB_Semiring GxB_MIN_ISGE_INT8; -extern GrB_Semiring GxB_MIN_ISGE_INT16; -extern GrB_Semiring GxB_MIN_ISGE_INT32; -extern GrB_Semiring GxB_MIN_ISGE_INT64; -extern GrB_Semiring GxB_MIN_ISGE_UINT8; -extern GrB_Semiring GxB_MIN_ISGE_UINT16; -extern GrB_Semiring GxB_MIN_ISGE_UINT32; -extern GrB_Semiring GxB_MIN_ISGE_UINT64; -extern GrB_Semiring GxB_MIN_ISGT_FP32; -extern GrB_Semiring GxB_MIN_ISGT_FP64; -extern GrB_Semiring GxB_MIN_ISGT_INT8; -extern GrB_Semiring GxB_MIN_ISGT_INT16; -extern GrB_Semiring GxB_MIN_ISGT_INT32; -extern GrB_Semiring GxB_MIN_ISGT_INT64; -extern GrB_Semiring GxB_MIN_ISGT_UINT8; -extern GrB_Semiring GxB_MIN_ISGT_UINT16; -extern GrB_Semiring GxB_MIN_ISGT_UINT32; -extern GrB_Semiring GxB_MIN_ISGT_UINT64; -extern GrB_Semiring GxB_MIN_ISLE_FP32; -extern GrB_Semiring GxB_MIN_ISLE_FP64; -extern GrB_Semiring GxB_MIN_ISLE_INT8; -extern GrB_Semiring GxB_MIN_ISLE_INT16; -extern GrB_Semiring GxB_MIN_ISLE_INT32; -extern GrB_Semiring GxB_MIN_ISLE_INT64; -extern GrB_Semiring GxB_MIN_ISLE_UINT8; -extern GrB_Semiring GxB_MIN_ISLE_UINT16; -extern GrB_Semiring GxB_MIN_ISLE_UINT32; -extern GrB_Semiring GxB_MIN_ISLE_UINT64; -extern GrB_Semiring GxB_MIN_ISLT_FP32; -extern GrB_Semiring GxB_MIN_ISLT_FP64; -extern GrB_Semiring GxB_MIN_ISLT_INT8; -extern GrB_Semiring GxB_MIN_ISLT_INT16; -extern GrB_Semiring GxB_MIN_ISLT_INT32; -extern GrB_Semiring GxB_MIN_ISLT_INT64; -extern GrB_Semiring GxB_MIN_ISLT_UINT8; -extern GrB_Semiring GxB_MIN_ISLT_UINT16; -extern GrB_Semiring GxB_MIN_ISLT_UINT32; -extern GrB_Semiring GxB_MIN_ISLT_UINT64; -extern GrB_Semiring GxB_MIN_ISNE_FP32; -extern GrB_Semiring GxB_MIN_ISNE_FP64; -extern GrB_Semiring GxB_MIN_ISNE_INT8; -extern GrB_Semiring GxB_MIN_ISNE_INT16; -extern GrB_Semiring GxB_MIN_ISNE_INT32; -extern GrB_Semiring GxB_MIN_ISNE_INT64; -extern GrB_Semiring GxB_MIN_ISNE_UINT8; -extern GrB_Semiring GxB_MIN_ISNE_UINT16; -extern GrB_Semiring GxB_MIN_ISNE_UINT32; -extern GrB_Semiring GxB_MIN_ISNE_UINT64; -extern GrB_Semiring GxB_MIN_LAND_FP32; -extern GrB_Semiring GxB_MIN_LAND_FP64; -extern GrB_Semiring GxB_MIN_LAND_INT8; -extern GrB_Semiring GxB_MIN_LAND_INT16; -extern GrB_Semiring GxB_MIN_LAND_INT32; -extern GrB_Semiring GxB_MIN_LAND_INT64; -extern GrB_Semiring GxB_MIN_LAND_UINT8; -extern GrB_Semiring GxB_MIN_LAND_UINT16; -extern GrB_Semiring GxB_MIN_LAND_UINT32; -extern GrB_Semiring GxB_MIN_LAND_UINT64; -extern GrB_Semiring GxB_MIN_LOR_FP32; -extern GrB_Semiring GxB_MIN_LOR_FP64; -extern GrB_Semiring GxB_MIN_LOR_INT8; -extern GrB_Semiring GxB_MIN_LOR_INT16; -extern GrB_Semiring GxB_MIN_LOR_INT32; -extern GrB_Semiring GxB_MIN_LOR_INT64; -extern GrB_Semiring GxB_MIN_LOR_UINT8; -extern GrB_Semiring GxB_MIN_LOR_UINT16; -extern GrB_Semiring GxB_MIN_LOR_UINT32; -extern GrB_Semiring GxB_MIN_LOR_UINT64; -extern GrB_Semiring GxB_MIN_LXOR_FP32; -extern GrB_Semiring GxB_MIN_LXOR_FP64; -extern GrB_Semiring GxB_MIN_LXOR_INT8; -extern GrB_Semiring GxB_MIN_LXOR_INT16; -extern GrB_Semiring GxB_MIN_LXOR_INT32; -extern GrB_Semiring GxB_MIN_LXOR_INT64; -extern GrB_Semiring GxB_MIN_LXOR_UINT8; -extern GrB_Semiring GxB_MIN_LXOR_UINT16; -extern GrB_Semiring GxB_MIN_LXOR_UINT32; -extern GrB_Semiring GxB_MIN_LXOR_UINT64; -extern GrB_Semiring GxB_MIN_MINUS_FP32; -extern GrB_Semiring GxB_MIN_MINUS_FP64; -extern GrB_Semiring GxB_MIN_MINUS_INT8; -extern GrB_Semiring GxB_MIN_MINUS_INT16; -extern GrB_Semiring GxB_MIN_MINUS_INT32; -extern GrB_Semiring GxB_MIN_MINUS_INT64; -extern GrB_Semiring GxB_MIN_MINUS_UINT8; -extern GrB_Semiring GxB_MIN_MINUS_UINT16; -extern GrB_Semiring GxB_MIN_MINUS_UINT32; -extern GrB_Semiring GxB_MIN_MINUS_UINT64; -extern GrB_Semiring GxB_MIN_MIN_FP32; -extern GrB_Semiring GxB_MIN_MIN_FP64; -extern GrB_Semiring GxB_MIN_MIN_INT8; -extern GrB_Semiring GxB_MIN_MIN_INT16; -extern GrB_Semiring GxB_MIN_MIN_INT32; -extern GrB_Semiring GxB_MIN_MIN_INT64; -extern GrB_Semiring GxB_MIN_MIN_UINT8; -extern GrB_Semiring GxB_MIN_MIN_UINT16; -extern GrB_Semiring GxB_MIN_MIN_UINT32; -extern GrB_Semiring GxB_MIN_MIN_UINT64; -extern GrB_Semiring GxB_MIN_PAIR_FP32; -extern GrB_Semiring GxB_MIN_PAIR_FP64; -extern GrB_Semiring GxB_MIN_PAIR_INT8; -extern GrB_Semiring GxB_MIN_PAIR_INT16; -extern GrB_Semiring GxB_MIN_PAIR_INT32; -extern GrB_Semiring GxB_MIN_PAIR_INT64; -extern GrB_Semiring GxB_MIN_PAIR_UINT8; -extern GrB_Semiring GxB_MIN_PAIR_UINT16; -extern GrB_Semiring GxB_MIN_PAIR_UINT32; -extern GrB_Semiring GxB_MIN_PAIR_UINT64; -extern GrB_Semiring GxB_MIN_RDIV_FP32; -extern GrB_Semiring GxB_MIN_RDIV_FP64; -extern GrB_Semiring GxB_MIN_RDIV_INT8; -extern GrB_Semiring GxB_MIN_RDIV_INT16; -extern GrB_Semiring GxB_MIN_RDIV_INT32; -extern GrB_Semiring GxB_MIN_RDIV_INT64; -extern GrB_Semiring GxB_MIN_RDIV_UINT8; -extern GrB_Semiring GxB_MIN_RDIV_UINT16; -extern GrB_Semiring GxB_MIN_RDIV_UINT32; -extern GrB_Semiring GxB_MIN_RDIV_UINT64; -extern GrB_Semiring GxB_MIN_RMINUS_FP32; -extern GrB_Semiring GxB_MIN_RMINUS_FP64; -extern GrB_Semiring GxB_MIN_RMINUS_INT8; -extern GrB_Semiring GxB_MIN_RMINUS_INT16; -extern GrB_Semiring GxB_MIN_RMINUS_INT32; -extern GrB_Semiring GxB_MIN_RMINUS_INT64; -extern GrB_Semiring GxB_MIN_RMINUS_UINT8; -extern GrB_Semiring GxB_MIN_RMINUS_UINT16; -extern GrB_Semiring GxB_MIN_RMINUS_UINT32; -extern GrB_Semiring GxB_MIN_RMINUS_UINT64; -extern GrB_Semiring GxB_MIN_SECONDI1_INT32; -extern GrB_Semiring GxB_MIN_SECONDI1_INT64; -extern GrB_Semiring GxB_MIN_SECONDI_INT32; -extern GrB_Semiring GxB_MIN_SECONDI_INT64; -extern GrB_Semiring GxB_MIN_SECONDJ1_INT32; -extern GrB_Semiring GxB_MIN_SECONDJ1_INT64; -extern GrB_Semiring GxB_MIN_SECONDJ_INT32; -extern GrB_Semiring GxB_MIN_SECONDJ_INT64; -extern GrB_Semiring GxB_PLUS_DIV_FP32; -extern GrB_Semiring GxB_PLUS_DIV_FP64; -extern GrB_Semiring GxB_PLUS_DIV_INT8; -extern GrB_Semiring GxB_PLUS_DIV_INT16; -extern GrB_Semiring GxB_PLUS_DIV_INT32; -extern GrB_Semiring GxB_PLUS_DIV_INT64; -extern GrB_Semiring GxB_PLUS_DIV_UINT8; -extern GrB_Semiring GxB_PLUS_DIV_UINT16; -extern GrB_Semiring GxB_PLUS_DIV_UINT32; -extern GrB_Semiring GxB_PLUS_DIV_UINT64; -extern GrB_Semiring GxB_PLUS_FIRSTI1_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTI1_INT64; -extern GrB_Semiring GxB_PLUS_FIRSTI_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTI_INT64; -extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT64; -extern GrB_Semiring GxB_PLUS_FIRSTJ_INT32; -extern GrB_Semiring GxB_PLUS_FIRSTJ_INT64; -extern GrB_Semiring GxB_PLUS_FIRST_FP32; -extern GrB_Semiring GxB_PLUS_FIRST_FP64; -extern GrB_Semiring GxB_PLUS_FIRST_INT8; -extern GrB_Semiring GxB_PLUS_FIRST_INT16; -extern GrB_Semiring GxB_PLUS_FIRST_INT32; -extern GrB_Semiring GxB_PLUS_FIRST_INT64; -extern GrB_Semiring GxB_PLUS_FIRST_UINT8; -extern GrB_Semiring GxB_PLUS_FIRST_UINT16; -extern GrB_Semiring GxB_PLUS_FIRST_UINT32; -extern GrB_Semiring GxB_PLUS_FIRST_UINT64; -extern GrB_Semiring GxB_PLUS_ISEQ_FP32; -extern GrB_Semiring GxB_PLUS_ISEQ_FP64; -extern GrB_Semiring GxB_PLUS_ISEQ_INT8; -extern GrB_Semiring GxB_PLUS_ISEQ_INT16; -extern GrB_Semiring GxB_PLUS_ISEQ_INT32; -extern GrB_Semiring GxB_PLUS_ISEQ_INT64; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT8; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT16; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT32; -extern GrB_Semiring GxB_PLUS_ISEQ_UINT64; -extern GrB_Semiring GxB_PLUS_ISGE_FP32; -extern GrB_Semiring GxB_PLUS_ISGE_FP64; -extern GrB_Semiring GxB_PLUS_ISGE_INT8; -extern GrB_Semiring GxB_PLUS_ISGE_INT16; -extern GrB_Semiring GxB_PLUS_ISGE_INT32; -extern GrB_Semiring GxB_PLUS_ISGE_INT64; -extern GrB_Semiring GxB_PLUS_ISGE_UINT8; -extern GrB_Semiring GxB_PLUS_ISGE_UINT16; -extern GrB_Semiring GxB_PLUS_ISGE_UINT32; -extern GrB_Semiring GxB_PLUS_ISGE_UINT64; -extern GrB_Semiring GxB_PLUS_ISGT_FP32; -extern GrB_Semiring GxB_PLUS_ISGT_FP64; -extern GrB_Semiring GxB_PLUS_ISGT_INT8; -extern GrB_Semiring GxB_PLUS_ISGT_INT16; -extern GrB_Semiring GxB_PLUS_ISGT_INT32; -extern GrB_Semiring GxB_PLUS_ISGT_INT64; -extern GrB_Semiring GxB_PLUS_ISGT_UINT8; -extern GrB_Semiring GxB_PLUS_ISGT_UINT16; -extern GrB_Semiring GxB_PLUS_ISGT_UINT32; -extern GrB_Semiring GxB_PLUS_ISGT_UINT64; -extern GrB_Semiring GxB_PLUS_ISLE_FP32; -extern GrB_Semiring GxB_PLUS_ISLE_FP64; -extern GrB_Semiring GxB_PLUS_ISLE_INT8; -extern GrB_Semiring GxB_PLUS_ISLE_INT16; -extern GrB_Semiring GxB_PLUS_ISLE_INT32; -extern GrB_Semiring GxB_PLUS_ISLE_INT64; -extern GrB_Semiring GxB_PLUS_ISLE_UINT8; -extern GrB_Semiring GxB_PLUS_ISLE_UINT16; -extern GrB_Semiring GxB_PLUS_ISLE_UINT32; -extern GrB_Semiring GxB_PLUS_ISLE_UINT64; -extern GrB_Semiring GxB_PLUS_ISLT_FP32; -extern GrB_Semiring GxB_PLUS_ISLT_FP64; -extern GrB_Semiring GxB_PLUS_ISLT_INT8; -extern GrB_Semiring GxB_PLUS_ISLT_INT16; -extern GrB_Semiring GxB_PLUS_ISLT_INT32; -extern GrB_Semiring GxB_PLUS_ISLT_INT64; -extern GrB_Semiring GxB_PLUS_ISLT_UINT8; -extern GrB_Semiring GxB_PLUS_ISLT_UINT16; -extern GrB_Semiring GxB_PLUS_ISLT_UINT32; -extern GrB_Semiring GxB_PLUS_ISLT_UINT64; -extern GrB_Semiring GxB_PLUS_ISNE_FP32; -extern GrB_Semiring GxB_PLUS_ISNE_FP64; -extern GrB_Semiring GxB_PLUS_ISNE_INT8; -extern GrB_Semiring GxB_PLUS_ISNE_INT16; -extern GrB_Semiring GxB_PLUS_ISNE_INT32; -extern GrB_Semiring GxB_PLUS_ISNE_INT64; -extern GrB_Semiring GxB_PLUS_ISNE_UINT8; -extern GrB_Semiring GxB_PLUS_ISNE_UINT16; -extern GrB_Semiring GxB_PLUS_ISNE_UINT32; -extern GrB_Semiring GxB_PLUS_ISNE_UINT64; -extern GrB_Semiring GxB_PLUS_LAND_FP32; -extern GrB_Semiring GxB_PLUS_LAND_FP64; -extern GrB_Semiring GxB_PLUS_LAND_INT8; -extern GrB_Semiring GxB_PLUS_LAND_INT16; -extern GrB_Semiring GxB_PLUS_LAND_INT32; -extern GrB_Semiring GxB_PLUS_LAND_INT64; -extern GrB_Semiring GxB_PLUS_LAND_UINT8; -extern GrB_Semiring GxB_PLUS_LAND_UINT16; -extern GrB_Semiring GxB_PLUS_LAND_UINT32; -extern GrB_Semiring GxB_PLUS_LAND_UINT64; -extern GrB_Semiring GxB_PLUS_LOR_FP32; -extern GrB_Semiring GxB_PLUS_LOR_FP64; -extern GrB_Semiring GxB_PLUS_LOR_INT8; -extern GrB_Semiring GxB_PLUS_LOR_INT16; -extern GrB_Semiring GxB_PLUS_LOR_INT32; -extern GrB_Semiring GxB_PLUS_LOR_INT64; -extern GrB_Semiring GxB_PLUS_LOR_UINT8; -extern GrB_Semiring GxB_PLUS_LOR_UINT16; -extern GrB_Semiring GxB_PLUS_LOR_UINT32; -extern GrB_Semiring GxB_PLUS_LOR_UINT64; -extern GrB_Semiring GxB_PLUS_LXOR_FP32; -extern GrB_Semiring GxB_PLUS_LXOR_FP64; -extern GrB_Semiring GxB_PLUS_LXOR_INT8; -extern GrB_Semiring GxB_PLUS_LXOR_INT16; -extern GrB_Semiring GxB_PLUS_LXOR_INT32; -extern GrB_Semiring GxB_PLUS_LXOR_INT64; -extern GrB_Semiring GxB_PLUS_LXOR_UINT8; -extern GrB_Semiring GxB_PLUS_LXOR_UINT16; -extern GrB_Semiring GxB_PLUS_LXOR_UINT32; -extern GrB_Semiring GxB_PLUS_LXOR_UINT64; -extern GrB_Semiring GxB_PLUS_MAX_FP32; -extern GrB_Semiring GxB_PLUS_MAX_FP64; -extern GrB_Semiring GxB_PLUS_MAX_INT8; -extern GrB_Semiring GxB_PLUS_MAX_INT16; -extern GrB_Semiring GxB_PLUS_MAX_INT32; -extern GrB_Semiring GxB_PLUS_MAX_INT64; -extern GrB_Semiring GxB_PLUS_MAX_UINT8; -extern GrB_Semiring GxB_PLUS_MAX_UINT16; -extern GrB_Semiring GxB_PLUS_MAX_UINT32; -extern GrB_Semiring GxB_PLUS_MAX_UINT64; -extern GrB_Semiring GxB_PLUS_MINUS_FP32; -extern GrB_Semiring GxB_PLUS_MINUS_FP64; -extern GrB_Semiring GxB_PLUS_MINUS_INT8; -extern GrB_Semiring GxB_PLUS_MINUS_INT16; -extern GrB_Semiring GxB_PLUS_MINUS_INT32; -extern GrB_Semiring GxB_PLUS_MINUS_INT64; -extern GrB_Semiring GxB_PLUS_MINUS_UINT8; -extern GrB_Semiring GxB_PLUS_MINUS_UINT16; -extern GrB_Semiring GxB_PLUS_MINUS_UINT32; -extern GrB_Semiring GxB_PLUS_MINUS_UINT64; -extern GrB_Semiring GxB_PLUS_PAIR_FP32; -extern GrB_Semiring GxB_PLUS_PAIR_FP64; -extern GrB_Semiring GxB_PLUS_PAIR_INT8; -extern GrB_Semiring GxB_PLUS_PAIR_INT16; -extern GrB_Semiring GxB_PLUS_PAIR_INT32; -extern GrB_Semiring GxB_PLUS_PAIR_INT64; -extern GrB_Semiring GxB_PLUS_PAIR_UINT8; -extern GrB_Semiring GxB_PLUS_PAIR_UINT16; -extern GrB_Semiring GxB_PLUS_PAIR_UINT32; -extern GrB_Semiring GxB_PLUS_PAIR_UINT64; -extern GrB_Semiring GxB_PLUS_PLUS_FP32; -extern GrB_Semiring GxB_PLUS_PLUS_FP64; -extern GrB_Semiring GxB_PLUS_PLUS_INT8; -extern GrB_Semiring GxB_PLUS_PLUS_INT16; -extern GrB_Semiring GxB_PLUS_PLUS_INT32; -extern GrB_Semiring GxB_PLUS_PLUS_INT64; -extern GrB_Semiring GxB_PLUS_PLUS_UINT8; -extern GrB_Semiring GxB_PLUS_PLUS_UINT16; -extern GrB_Semiring GxB_PLUS_PLUS_UINT32; -extern GrB_Semiring GxB_PLUS_PLUS_UINT64; -extern GrB_Semiring GxB_PLUS_RDIV_FP32; -extern GrB_Semiring GxB_PLUS_RDIV_FP64; -extern GrB_Semiring GxB_PLUS_RDIV_INT8; -extern GrB_Semiring GxB_PLUS_RDIV_INT16; -extern GrB_Semiring GxB_PLUS_RDIV_INT32; -extern GrB_Semiring GxB_PLUS_RDIV_INT64; -extern GrB_Semiring GxB_PLUS_RDIV_UINT8; -extern GrB_Semiring GxB_PLUS_RDIV_UINT16; -extern GrB_Semiring GxB_PLUS_RDIV_UINT32; -extern GrB_Semiring GxB_PLUS_RDIV_UINT64; -extern GrB_Semiring GxB_PLUS_RMINUS_FP32; -extern GrB_Semiring GxB_PLUS_RMINUS_FP64; -extern GrB_Semiring GxB_PLUS_RMINUS_INT8; -extern GrB_Semiring GxB_PLUS_RMINUS_INT16; -extern GrB_Semiring GxB_PLUS_RMINUS_INT32; -extern GrB_Semiring GxB_PLUS_RMINUS_INT64; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT8; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT16; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT32; -extern GrB_Semiring GxB_PLUS_RMINUS_UINT64; -extern GrB_Semiring GxB_PLUS_SECONDI1_INT32; -extern GrB_Semiring GxB_PLUS_SECONDI1_INT64; -extern GrB_Semiring GxB_PLUS_SECONDI_INT32; -extern GrB_Semiring GxB_PLUS_SECONDI_INT64; -extern GrB_Semiring GxB_PLUS_SECONDJ1_INT32; -extern GrB_Semiring GxB_PLUS_SECONDJ1_INT64; -extern GrB_Semiring GxB_PLUS_SECONDJ_INT32; -extern GrB_Semiring GxB_PLUS_SECONDJ_INT64; -extern GrB_Semiring GxB_PLUS_SECOND_FP32; -extern GrB_Semiring GxB_PLUS_SECOND_FP64; -extern GrB_Semiring GxB_PLUS_SECOND_INT8; -extern GrB_Semiring GxB_PLUS_SECOND_INT16; -extern GrB_Semiring GxB_PLUS_SECOND_INT32; -extern GrB_Semiring GxB_PLUS_SECOND_INT64; -extern GrB_Semiring GxB_PLUS_SECOND_UINT8; -extern GrB_Semiring GxB_PLUS_SECOND_UINT16; -extern GrB_Semiring GxB_PLUS_SECOND_UINT32; -extern GrB_Semiring GxB_PLUS_SECOND_UINT64; -extern GrB_Semiring GxB_TIMES_DIV_FP32; -extern GrB_Semiring GxB_TIMES_DIV_FP64; -extern GrB_Semiring GxB_TIMES_DIV_INT8; -extern GrB_Semiring GxB_TIMES_DIV_INT16; -extern GrB_Semiring GxB_TIMES_DIV_INT32; -extern GrB_Semiring GxB_TIMES_DIV_INT64; -extern GrB_Semiring GxB_TIMES_DIV_UINT8; -extern GrB_Semiring GxB_TIMES_DIV_UINT16; -extern GrB_Semiring GxB_TIMES_DIV_UINT32; -extern GrB_Semiring GxB_TIMES_DIV_UINT64; -extern GrB_Semiring GxB_TIMES_FIRSTI1_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTI1_INT64; -extern GrB_Semiring GxB_TIMES_FIRSTI_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTI_INT64; -extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT64; -extern GrB_Semiring GxB_TIMES_FIRSTJ_INT32; -extern GrB_Semiring GxB_TIMES_FIRSTJ_INT64; -extern GrB_Semiring GxB_TIMES_FIRST_FP32; -extern GrB_Semiring GxB_TIMES_FIRST_FP64; -extern GrB_Semiring GxB_TIMES_FIRST_INT8; -extern GrB_Semiring GxB_TIMES_FIRST_INT16; -extern GrB_Semiring GxB_TIMES_FIRST_INT32; -extern GrB_Semiring GxB_TIMES_FIRST_INT64; -extern GrB_Semiring GxB_TIMES_FIRST_UINT8; -extern GrB_Semiring GxB_TIMES_FIRST_UINT16; -extern GrB_Semiring GxB_TIMES_FIRST_UINT32; -extern GrB_Semiring GxB_TIMES_FIRST_UINT64; -extern GrB_Semiring GxB_TIMES_ISEQ_FP32; -extern GrB_Semiring GxB_TIMES_ISEQ_FP64; -extern GrB_Semiring GxB_TIMES_ISEQ_INT8; -extern GrB_Semiring GxB_TIMES_ISEQ_INT16; -extern GrB_Semiring GxB_TIMES_ISEQ_INT32; -extern GrB_Semiring GxB_TIMES_ISEQ_INT64; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT8; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT16; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT32; -extern GrB_Semiring GxB_TIMES_ISEQ_UINT64; -extern GrB_Semiring GxB_TIMES_ISGE_FP32; -extern GrB_Semiring GxB_TIMES_ISGE_FP64; -extern GrB_Semiring GxB_TIMES_ISGE_INT8; -extern GrB_Semiring GxB_TIMES_ISGE_INT16; -extern GrB_Semiring GxB_TIMES_ISGE_INT32; -extern GrB_Semiring GxB_TIMES_ISGE_INT64; -extern GrB_Semiring GxB_TIMES_ISGE_UINT8; -extern GrB_Semiring GxB_TIMES_ISGE_UINT16; -extern GrB_Semiring GxB_TIMES_ISGE_UINT32; -extern GrB_Semiring GxB_TIMES_ISGE_UINT64; -extern GrB_Semiring GxB_TIMES_ISGT_FP32; -extern GrB_Semiring GxB_TIMES_ISGT_FP64; -extern GrB_Semiring GxB_TIMES_ISGT_INT8; -extern GrB_Semiring GxB_TIMES_ISGT_INT16; -extern GrB_Semiring GxB_TIMES_ISGT_INT32; -extern GrB_Semiring GxB_TIMES_ISGT_INT64; -extern GrB_Semiring GxB_TIMES_ISGT_UINT8; -extern GrB_Semiring GxB_TIMES_ISGT_UINT16; -extern GrB_Semiring GxB_TIMES_ISGT_UINT32; -extern GrB_Semiring GxB_TIMES_ISGT_UINT64; -extern GrB_Semiring GxB_TIMES_ISLE_FP32; -extern GrB_Semiring GxB_TIMES_ISLE_FP64; -extern GrB_Semiring GxB_TIMES_ISLE_INT8; -extern GrB_Semiring GxB_TIMES_ISLE_INT16; -extern GrB_Semiring GxB_TIMES_ISLE_INT32; -extern GrB_Semiring GxB_TIMES_ISLE_INT64; -extern GrB_Semiring GxB_TIMES_ISLE_UINT8; -extern GrB_Semiring GxB_TIMES_ISLE_UINT16; -extern GrB_Semiring GxB_TIMES_ISLE_UINT32; -extern GrB_Semiring GxB_TIMES_ISLE_UINT64; -extern GrB_Semiring GxB_TIMES_ISLT_FP32; -extern GrB_Semiring GxB_TIMES_ISLT_FP64; -extern GrB_Semiring GxB_TIMES_ISLT_INT8; -extern GrB_Semiring GxB_TIMES_ISLT_INT16; -extern GrB_Semiring GxB_TIMES_ISLT_INT32; -extern GrB_Semiring GxB_TIMES_ISLT_INT64; -extern GrB_Semiring GxB_TIMES_ISLT_UINT8; -extern GrB_Semiring GxB_TIMES_ISLT_UINT16; -extern GrB_Semiring GxB_TIMES_ISLT_UINT32; -extern GrB_Semiring GxB_TIMES_ISLT_UINT64; -extern GrB_Semiring GxB_TIMES_ISNE_FP32; -extern GrB_Semiring GxB_TIMES_ISNE_FP64; -extern GrB_Semiring GxB_TIMES_ISNE_INT8; -extern GrB_Semiring GxB_TIMES_ISNE_INT16; -extern GrB_Semiring GxB_TIMES_ISNE_INT32; -extern GrB_Semiring GxB_TIMES_ISNE_INT64; -extern GrB_Semiring GxB_TIMES_ISNE_UINT8; -extern GrB_Semiring GxB_TIMES_ISNE_UINT16; -extern GrB_Semiring GxB_TIMES_ISNE_UINT32; -extern GrB_Semiring GxB_TIMES_ISNE_UINT64; -extern GrB_Semiring GxB_TIMES_LAND_FP32; -extern GrB_Semiring GxB_TIMES_LAND_FP64; -extern GrB_Semiring GxB_TIMES_LAND_INT8; -extern GrB_Semiring GxB_TIMES_LAND_INT16; -extern GrB_Semiring GxB_TIMES_LAND_INT32; -extern GrB_Semiring GxB_TIMES_LAND_INT64; -extern GrB_Semiring GxB_TIMES_LAND_UINT8; -extern GrB_Semiring GxB_TIMES_LAND_UINT16; -extern GrB_Semiring GxB_TIMES_LAND_UINT32; -extern GrB_Semiring GxB_TIMES_LAND_UINT64; -extern GrB_Semiring GxB_TIMES_LOR_FP32; -extern GrB_Semiring GxB_TIMES_LOR_FP64; -extern GrB_Semiring GxB_TIMES_LOR_INT8; -extern GrB_Semiring GxB_TIMES_LOR_INT16; -extern GrB_Semiring GxB_TIMES_LOR_INT32; -extern GrB_Semiring GxB_TIMES_LOR_INT64; -extern GrB_Semiring GxB_TIMES_LOR_UINT8; -extern GrB_Semiring GxB_TIMES_LOR_UINT16; -extern GrB_Semiring GxB_TIMES_LOR_UINT32; -extern GrB_Semiring GxB_TIMES_LOR_UINT64; -extern GrB_Semiring GxB_TIMES_LXOR_FP32; -extern GrB_Semiring GxB_TIMES_LXOR_FP64; -extern GrB_Semiring GxB_TIMES_LXOR_INT8; -extern GrB_Semiring GxB_TIMES_LXOR_INT16; -extern GrB_Semiring GxB_TIMES_LXOR_INT32; -extern GrB_Semiring GxB_TIMES_LXOR_INT64; -extern GrB_Semiring GxB_TIMES_LXOR_UINT8; -extern GrB_Semiring GxB_TIMES_LXOR_UINT16; -extern GrB_Semiring GxB_TIMES_LXOR_UINT32; -extern GrB_Semiring GxB_TIMES_LXOR_UINT64; -extern GrB_Semiring GxB_TIMES_MAX_FP32; -extern GrB_Semiring GxB_TIMES_MAX_FP64; -extern GrB_Semiring GxB_TIMES_MAX_INT8; -extern GrB_Semiring GxB_TIMES_MAX_INT16; -extern GrB_Semiring GxB_TIMES_MAX_INT32; -extern GrB_Semiring GxB_TIMES_MAX_INT64; -extern GrB_Semiring GxB_TIMES_MAX_UINT8; -extern GrB_Semiring GxB_TIMES_MAX_UINT16; -extern GrB_Semiring GxB_TIMES_MAX_UINT32; -extern GrB_Semiring GxB_TIMES_MAX_UINT64; -extern GrB_Semiring GxB_TIMES_MINUS_FP32; -extern GrB_Semiring GxB_TIMES_MINUS_FP64; -extern GrB_Semiring GxB_TIMES_MINUS_INT8; -extern GrB_Semiring GxB_TIMES_MINUS_INT16; -extern GrB_Semiring GxB_TIMES_MINUS_INT32; -extern GrB_Semiring GxB_TIMES_MINUS_INT64; -extern GrB_Semiring GxB_TIMES_MINUS_UINT8; -extern GrB_Semiring GxB_TIMES_MINUS_UINT16; -extern GrB_Semiring GxB_TIMES_MINUS_UINT32; -extern GrB_Semiring GxB_TIMES_MINUS_UINT64; -extern GrB_Semiring GxB_TIMES_MIN_FP32; -extern GrB_Semiring GxB_TIMES_MIN_FP64; -extern GrB_Semiring GxB_TIMES_MIN_INT8; -extern GrB_Semiring GxB_TIMES_MIN_INT16; -extern GrB_Semiring GxB_TIMES_MIN_INT32; -extern GrB_Semiring GxB_TIMES_MIN_INT64; -extern GrB_Semiring GxB_TIMES_MIN_UINT8; -extern GrB_Semiring GxB_TIMES_MIN_UINT16; -extern GrB_Semiring GxB_TIMES_MIN_UINT32; -extern GrB_Semiring GxB_TIMES_MIN_UINT64; -extern GrB_Semiring GxB_TIMES_PAIR_FP32; -extern GrB_Semiring GxB_TIMES_PAIR_FP64; -extern GrB_Semiring GxB_TIMES_PAIR_INT8; -extern GrB_Semiring GxB_TIMES_PAIR_INT16; -extern GrB_Semiring GxB_TIMES_PAIR_INT32; -extern GrB_Semiring GxB_TIMES_PAIR_INT64; -extern GrB_Semiring GxB_TIMES_PAIR_UINT8; -extern GrB_Semiring GxB_TIMES_PAIR_UINT16; -extern GrB_Semiring GxB_TIMES_PAIR_UINT32; -extern GrB_Semiring GxB_TIMES_PAIR_UINT64; -extern GrB_Semiring GxB_TIMES_PLUS_FP32; -extern GrB_Semiring GxB_TIMES_PLUS_FP64; -extern GrB_Semiring GxB_TIMES_PLUS_INT8; -extern GrB_Semiring GxB_TIMES_PLUS_INT16; -extern GrB_Semiring GxB_TIMES_PLUS_INT32; -extern GrB_Semiring GxB_TIMES_PLUS_INT64; -extern GrB_Semiring GxB_TIMES_PLUS_UINT8; -extern GrB_Semiring GxB_TIMES_PLUS_UINT16; -extern GrB_Semiring GxB_TIMES_PLUS_UINT32; -extern GrB_Semiring GxB_TIMES_PLUS_UINT64; -extern GrB_Semiring GxB_TIMES_RDIV_FP32; -extern GrB_Semiring GxB_TIMES_RDIV_FP64; -extern GrB_Semiring GxB_TIMES_RDIV_INT8; -extern GrB_Semiring GxB_TIMES_RDIV_INT16; -extern GrB_Semiring GxB_TIMES_RDIV_INT32; -extern GrB_Semiring GxB_TIMES_RDIV_INT64; -extern GrB_Semiring GxB_TIMES_RDIV_UINT8; -extern GrB_Semiring GxB_TIMES_RDIV_UINT16; -extern GrB_Semiring GxB_TIMES_RDIV_UINT32; -extern GrB_Semiring GxB_TIMES_RDIV_UINT64; -extern GrB_Semiring GxB_TIMES_RMINUS_FP32; -extern GrB_Semiring GxB_TIMES_RMINUS_FP64; -extern GrB_Semiring GxB_TIMES_RMINUS_INT8; -extern GrB_Semiring GxB_TIMES_RMINUS_INT16; -extern GrB_Semiring GxB_TIMES_RMINUS_INT32; -extern GrB_Semiring GxB_TIMES_RMINUS_INT64; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT8; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT16; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT32; -extern GrB_Semiring GxB_TIMES_RMINUS_UINT64; -extern GrB_Semiring GxB_TIMES_SECONDI1_INT32; -extern GrB_Semiring GxB_TIMES_SECONDI1_INT64; -extern GrB_Semiring GxB_TIMES_SECONDI_INT32; -extern GrB_Semiring GxB_TIMES_SECONDI_INT64; -extern GrB_Semiring GxB_TIMES_SECONDJ1_INT32; -extern GrB_Semiring GxB_TIMES_SECONDJ1_INT64; -extern GrB_Semiring GxB_TIMES_SECONDJ_INT32; -extern GrB_Semiring GxB_TIMES_SECONDJ_INT64; -extern GrB_Semiring GxB_TIMES_SECOND_FP32; -extern GrB_Semiring GxB_TIMES_SECOND_FP64; -extern GrB_Semiring GxB_TIMES_SECOND_INT8; -extern GrB_Semiring GxB_TIMES_SECOND_INT16; -extern GrB_Semiring GxB_TIMES_SECOND_INT32; -extern GrB_Semiring GxB_TIMES_SECOND_INT64; -extern GrB_Semiring GxB_TIMES_SECOND_UINT8; -extern GrB_Semiring GxB_TIMES_SECOND_UINT16; -extern GrB_Semiring GxB_TIMES_SECOND_UINT32; -extern GrB_Semiring GxB_TIMES_SECOND_UINT64; -extern GrB_Semiring GxB_TIMES_TIMES_FP32; -extern GrB_Semiring GxB_TIMES_TIMES_FP64; -extern GrB_Semiring GxB_TIMES_TIMES_INT8; -extern GrB_Semiring GxB_TIMES_TIMES_INT16; -extern GrB_Semiring GxB_TIMES_TIMES_INT32; -extern GrB_Semiring GxB_TIMES_TIMES_INT64; -extern GrB_Semiring GxB_TIMES_TIMES_UINT8; -extern GrB_Semiring GxB_TIMES_TIMES_UINT16; -extern GrB_Semiring GxB_TIMES_TIMES_UINT32; -extern GrB_Semiring GxB_TIMES_TIMES_UINT64; -extern GrB_UnaryOp GxB_ACOSH_FP32; -extern GrB_UnaryOp GxB_ACOSH_FP64; -extern GrB_UnaryOp GxB_ACOS_FP32; -extern GrB_UnaryOp GxB_ACOS_FP64; -extern GrB_UnaryOp GxB_ASINH_FP32; -extern GrB_UnaryOp GxB_ASINH_FP64; -extern GrB_UnaryOp GxB_ASIN_FP32; -extern GrB_UnaryOp GxB_ASIN_FP64; -extern GrB_UnaryOp GxB_ATANH_FP32; -extern GrB_UnaryOp GxB_ATANH_FP64; -extern GrB_UnaryOp GxB_ATAN_FP32; -extern GrB_UnaryOp GxB_ATAN_FP64; -extern GrB_UnaryOp GxB_CEIL_FP32; -extern GrB_UnaryOp GxB_CEIL_FP64; -extern GrB_UnaryOp GxB_COSH_FP32; -extern GrB_UnaryOp GxB_COSH_FP64; -extern GrB_UnaryOp GxB_COS_FP32; -extern GrB_UnaryOp GxB_COS_FP64; -extern GrB_UnaryOp GxB_ERFC_FP32; -extern GrB_UnaryOp GxB_ERFC_FP64; -extern GrB_UnaryOp GxB_ERF_FP32; -extern GrB_UnaryOp GxB_ERF_FP64; -extern GrB_UnaryOp GxB_EXP2_FP32; -extern GrB_UnaryOp GxB_EXP2_FP64; -extern GrB_UnaryOp GxB_EXPM1_FP32; -extern GrB_UnaryOp GxB_EXPM1_FP64; -extern GrB_UnaryOp GxB_EXP_FP32; -extern GrB_UnaryOp GxB_EXP_FP64; -extern GrB_UnaryOp GxB_FLOOR_FP32; -extern GrB_UnaryOp GxB_FLOOR_FP64; -extern GrB_UnaryOp GxB_FREXPE_FP32; -extern GrB_UnaryOp GxB_FREXPE_FP64; -extern GrB_UnaryOp GxB_FREXPX_FP32; -extern GrB_UnaryOp GxB_FREXPX_FP64; -extern GrB_UnaryOp GxB_ISFINITE_FP32; -extern GrB_UnaryOp GxB_ISFINITE_FP64; -extern GrB_UnaryOp GxB_ISINF_FP32; -extern GrB_UnaryOp GxB_ISINF_FP64; -extern GrB_UnaryOp GxB_ISNAN_FP32; -extern GrB_UnaryOp GxB_ISNAN_FP64; -extern GrB_UnaryOp GxB_LGAMMA_FP32; -extern GrB_UnaryOp GxB_LGAMMA_FP64; -extern GrB_UnaryOp GxB_LNOT_BOOL; -extern GrB_UnaryOp GxB_LNOT_FP32; -extern GrB_UnaryOp GxB_LNOT_FP64; -extern GrB_UnaryOp GxB_LNOT_INT8; -extern GrB_UnaryOp GxB_LNOT_INT16; -extern GrB_UnaryOp GxB_LNOT_INT32; -extern GrB_UnaryOp GxB_LNOT_INT64; -extern GrB_UnaryOp GxB_LNOT_UINT8; -extern GrB_UnaryOp GxB_LNOT_UINT16; -extern GrB_UnaryOp GxB_LNOT_UINT32; -extern GrB_UnaryOp GxB_LNOT_UINT64; -extern GrB_UnaryOp GxB_LOG10_FP32; -extern GrB_UnaryOp GxB_LOG10_FP64; -extern GrB_UnaryOp GxB_LOG1P_FP32; -extern GrB_UnaryOp GxB_LOG1P_FP64; -extern GrB_UnaryOp GxB_LOG2_FP32; -extern GrB_UnaryOp GxB_LOG2_FP64; -extern GrB_UnaryOp GxB_LOG_FP32; -extern GrB_UnaryOp GxB_LOG_FP64; -extern GrB_UnaryOp GxB_ONE_BOOL; -extern GrB_UnaryOp GxB_ONE_FP32; -extern GrB_UnaryOp GxB_ONE_FP64; -extern GrB_UnaryOp GxB_ONE_INT8; -extern GrB_UnaryOp GxB_ONE_INT16; -extern GrB_UnaryOp GxB_ONE_INT32; -extern GrB_UnaryOp GxB_ONE_INT64; -extern GrB_UnaryOp GxB_ONE_UINT8; -extern GrB_UnaryOp GxB_ONE_UINT16; -extern GrB_UnaryOp GxB_ONE_UINT32; -extern GrB_UnaryOp GxB_ONE_UINT64; -extern GrB_UnaryOp GxB_POSITIONI1_INT32; -extern GrB_UnaryOp GxB_POSITIONI1_INT64; -extern GrB_UnaryOp GxB_POSITIONI_INT32; -extern GrB_UnaryOp GxB_POSITIONI_INT64; -extern GrB_UnaryOp GxB_POSITIONJ1_INT32; -extern GrB_UnaryOp GxB_POSITIONJ1_INT64; -extern GrB_UnaryOp GxB_POSITIONJ_INT32; -extern GrB_UnaryOp GxB_POSITIONJ_INT64; -extern GrB_UnaryOp GxB_ROUND_FP32; -extern GrB_UnaryOp GxB_ROUND_FP64; -extern GrB_UnaryOp GxB_SIGNUM_FP32; -extern GrB_UnaryOp GxB_SIGNUM_FP64; -extern GrB_UnaryOp GxB_SINH_FP32; -extern GrB_UnaryOp GxB_SINH_FP64; -extern GrB_UnaryOp GxB_SIN_FP32; -extern GrB_UnaryOp GxB_SIN_FP64; -extern GrB_UnaryOp GxB_SQRT_FP32; -extern GrB_UnaryOp GxB_SQRT_FP64; -extern GrB_UnaryOp GxB_TANH_FP32; -extern GrB_UnaryOp GxB_TANH_FP64; -extern GrB_UnaryOp GxB_TAN_FP32; -extern GrB_UnaryOp GxB_TAN_FP64; -extern GrB_UnaryOp GxB_TGAMMA_FP32; -extern GrB_UnaryOp GxB_TGAMMA_FP64; -extern GrB_UnaryOp GxB_TRUNC_FP32; -extern GrB_UnaryOp GxB_TRUNC_FP64; - -/* GxB objects */ -extern GxB_SelectOp GxB_DIAG; -extern GxB_SelectOp GxB_EQ_THUNK; -extern GxB_SelectOp GxB_EQ_ZERO; -extern GxB_SelectOp GxB_GE_THUNK; -extern GxB_SelectOp GxB_GE_ZERO; -extern GxB_SelectOp GxB_GT_THUNK; -extern GxB_SelectOp GxB_GT_ZERO; -extern GxB_SelectOp GxB_LE_THUNK; -extern GxB_SelectOp GxB_LE_ZERO; -extern GxB_SelectOp GxB_LT_THUNK; -extern GxB_SelectOp GxB_LT_ZERO; -extern GxB_SelectOp GxB_NE_THUNK; -extern GxB_SelectOp GxB_NONZERO; -extern GxB_SelectOp GxB_OFFDIAG; -extern GxB_SelectOp GxB_TRIL; -extern GxB_SelectOp GxB_TRIU; - -/**************** -* GrB functions * -****************/ - -/* binary */ -extern GrB_Info GrB_BinaryOp_error(const char **error, const GrB_BinaryOp op); -extern GrB_Info GrB_BinaryOp_free(GrB_BinaryOp *binaryop); -extern GrB_Info GrB_BinaryOp_new(GrB_BinaryOp *binaryop, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); -extern GrB_Info GrB_BinaryOp_wait(GrB_BinaryOp *op); - -/* core */ -extern GrB_Info GrB_finalize(void); -extern GrB_Info GrB_getVersion(unsigned int *version, unsigned int *subversion); -extern GrB_Info GrB_init(GrB_Mode mode); - -/* descriptor */ -extern GrB_Info GrB_Descriptor_error(const char **error, const GrB_Descriptor d); -extern GrB_Info GrB_Descriptor_free(GrB_Descriptor *descriptor); -extern GrB_Info GrB_Descriptor_new(GrB_Descriptor *descriptor); -extern GrB_Info GrB_Descriptor_set(GrB_Descriptor desc, GrB_Desc_Field field, GrB_Desc_Value val); -extern GrB_Info GrB_Descriptor_wait(GrB_Descriptor *desc); - -/* matrix */ -extern GrB_Info GrB_Col_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); -extern GrB_Info GrB_Col_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_assign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_build_BOOL(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_FP32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_FP64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT8(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT16(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_INT64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UDT(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT8(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT16(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT32(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_build_UINT64(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Matrix_clear(GrB_Matrix A); -extern GrB_Info GrB_Matrix_dup(GrB_Matrix *C, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_eWiseAdd_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseAdd_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseAdd_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseMult_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseMult_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_eWiseMult_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_error(const char **error, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extract(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_extractElement_BOOL(bool *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_FP32(float *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_FP64(double *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT8(int8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT16(int16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT32(int32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_INT64(int64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UDT(void *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT8(uint8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT16(uint16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT32(uint32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractElement_UINT64(uint64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_extractTuples_BOOL(GrB_Index *I, GrB_Index *J, bool *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_FP32(GrB_Index *I, GrB_Index *J, float *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_FP64(GrB_Index *I, GrB_Index *J, double *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT8(GrB_Index *I, GrB_Index *J, int8_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT16(GrB_Index *I, GrB_Index *J, int16_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT32(GrB_Index *I, GrB_Index *J, int32_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_INT64(GrB_Index *I, GrB_Index *J, int64_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UDT(GrB_Index *I, GrB_Index *J, void *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT8(GrB_Index *I, GrB_Index *J, uint8_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT16(GrB_Index *I, GrB_Index *J, uint16_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT32(GrB_Index *I, GrB_Index *J, uint32_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_extractTuples_UINT64(GrB_Index *I, GrB_Index *J, uint64_t *X, GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_free(GrB_Matrix *A); -extern GrB_Info GrB_Matrix_kronecker_BinaryOp(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_kronecker_Monoid(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_kronecker_Semiring(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_ncols(GrB_Index *ncols, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_new(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols); -extern GrB_Info GrB_Matrix_nrows(GrB_Index *nrows, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_nvals(GrB_Index *nvals, const GrB_Matrix A); -extern GrB_Info GrB_Matrix_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_Matrix_removeElement(GrB_Matrix C, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_resize(GrB_Matrix C, GrB_Index nrows_new, GrB_Index ncols_new); -extern GrB_Info GrB_Matrix_setElement_BOOL(GrB_Matrix C, bool x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_FP32(GrB_Matrix C, float x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_FP64(GrB_Matrix C, double x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT8(GrB_Matrix C, int8_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT16(GrB_Matrix C, int16_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT32(GrB_Matrix C, int32_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_INT64(GrB_Matrix C, int64_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UDT(GrB_Matrix C, void *x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT8(GrB_Matrix C, uint8_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT16(GrB_Matrix C, uint16_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT32(GrB_Matrix C, uint32_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_setElement_UINT64(GrB_Matrix C, uint64_t x, GrB_Index i, GrB_Index j); -extern GrB_Info GrB_Matrix_wait(GrB_Matrix *A); -extern GrB_Info GrB_Row_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GrB_mxm(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); -extern GrB_Info GrB_mxv(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_transpose(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GrB_vxm(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Matrix A, const GrB_Descriptor desc); - -/* monoid */ -extern GrB_Info GrB_Monoid_error(const char **error, const GrB_Monoid monoid); -extern GrB_Info GrB_Monoid_free(GrB_Monoid *monoid); -extern GrB_Info GrB_Monoid_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity); -extern GrB_Info GrB_Monoid_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity); -extern GrB_Info GrB_Monoid_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity); -extern GrB_Info GrB_Monoid_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity); -extern GrB_Info GrB_Monoid_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity); -extern GrB_Info GrB_Monoid_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity); -extern GrB_Info GrB_Monoid_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity); -extern GrB_Info GrB_Monoid_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity); -extern GrB_Info GrB_Monoid_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity); -extern GrB_Info GrB_Monoid_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity); -extern GrB_Info GrB_Monoid_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity); -extern GrB_Info GrB_Monoid_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity); -extern GrB_Info GrB_Monoid_wait(GrB_Monoid *monoid); - -/* semiring */ -extern GrB_Info GrB_Semiring_error(const char **error, const GrB_Semiring semiring); -extern GrB_Info GrB_Semiring_free(GrB_Semiring *semiring); -extern GrB_Info GrB_Semiring_new(GrB_Semiring *semiring, GrB_Monoid add, GrB_BinaryOp multiply); -extern GrB_Info GrB_Semiring_wait(GrB_Semiring *semiring); - -/* type */ -extern GrB_Info GrB_Type_error(const char **error, const GrB_Type type); -extern GrB_Info GrB_Type_free(GrB_Type *type); -extern GrB_Info GrB_Type_new(GrB_Type *type, size_t sizeof_ctype); -extern GrB_Info GrB_Type_wait(GrB_Type *type); - -/* unary */ -extern GrB_Info GrB_UnaryOp_error(const char **error, const GrB_UnaryOp op); -extern GrB_Info GrB_UnaryOp_free(GrB_UnaryOp *unaryop); -extern GrB_Info GrB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype); -extern GrB_Info GrB_UnaryOp_wait(GrB_UnaryOp *op); - -/* vector */ -extern GrB_Info GrB_Vector_apply(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp1st_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_assign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_build_BOOL(GrB_Vector w, const GrB_Index *I, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_FP32(GrB_Vector w, const GrB_Index *I, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_FP64(GrB_Vector w, const GrB_Index *I, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT8(GrB_Vector w, const GrB_Index *I, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT16(GrB_Vector w, const GrB_Index *I, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT32(GrB_Vector w, const GrB_Index *I, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_INT64(GrB_Vector w, const GrB_Index *I, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UDT(GrB_Vector w, const GrB_Index *I, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT8(GrB_Vector w, const GrB_Index *I, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT16(GrB_Vector w, const GrB_Index *I, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT32(GrB_Vector w, const GrB_Index *I, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_build_UINT64(GrB_Vector w, const GrB_Index *I, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); -extern GrB_Info GrB_Vector_clear(GrB_Vector v); -extern GrB_Info GrB_Vector_dup(GrB_Vector *w, const GrB_Vector u); -extern GrB_Info GrB_Vector_eWiseAdd_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseAdd_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseAdd_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseMult_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseMult_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_eWiseMult_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_error(const char **error, const GrB_Vector v); -extern GrB_Info GrB_Vector_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_extractElement_BOOL(bool *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_FP32(float *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_FP64(double *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT8(int8_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT16(int16_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT32(int32_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_INT64(int64_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UDT(void *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT8(uint8_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT16(uint16_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT32(uint32_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractElement_UINT64(uint64_t *x, const GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_extractTuples_BOOL(GrB_Index *I, bool *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_FP32(GrB_Index *I, float *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_FP64(GrB_Index *I, double *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT8(GrB_Index *I, int8_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT16(GrB_Index *I, int16_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT32(GrB_Index *I, int32_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_INT64(GrB_Index *I, int64_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UDT(GrB_Index *I, void *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT8(GrB_Index *I, uint8_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT16(GrB_Index *I, uint16_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT32(GrB_Index *I, uint32_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_extractTuples_UINT64(GrB_Index *I, uint64_t *X, GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_free(GrB_Vector *v); -extern GrB_Info GrB_Vector_new(GrB_Vector *v, GrB_Type type, GrB_Index n); -extern GrB_Info GrB_Vector_nvals(GrB_Index *nvals, const GrB_Vector v); -extern GrB_Info GrB_Vector_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GrB_Vector_removeElement(GrB_Vector v, GrB_Index i); -extern GrB_Info GrB_Vector_resize(GrB_Vector w, GrB_Index nrows_new); -extern GrB_Info GrB_Vector_setElement_BOOL(GrB_Vector w, bool x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_FP32(GrB_Vector w, float x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_FP64(GrB_Vector w, double x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT8(GrB_Vector w, int8_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT16(GrB_Vector w, int16_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT32(GrB_Vector w, int32_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_INT64(GrB_Vector w, int64_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UDT(GrB_Vector w, void *x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT8(GrB_Vector w, uint8_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT16(GrB_Vector w, uint16_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT32(GrB_Vector w, uint32_t x, GrB_Index i); -extern GrB_Info GrB_Vector_setElement_UINT64(GrB_Vector w, uint64_t x, GrB_Index i); -extern GrB_Info GrB_Vector_size(GrB_Index *n, const GrB_Vector v); -extern GrB_Info GrB_Vector_wait(GrB_Vector *v); - -/*************** -* GB functions * -***************/ - -/* binary */ -extern GrB_Info GB_BinaryOp_new(GrB_BinaryOp *binaryop, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *name); - -/* selectop */ -extern GrB_Info GB_SelectOp_new(GxB_SelectOp *selectop, GxB_select_function function, GrB_Type xtype, GrB_Type ttype, const char *name); - -/* type */ -extern GrB_Info GB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *name); - -/* unary */ -extern GrB_Info GB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *name); - -/**************** -* GxB functions * -****************/ - -/* binary */ -extern GrB_Info GxB_BinaryOp_fprint(GrB_BinaryOp binaryop, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_BinaryOp_xtype(GrB_Type *xtype, GrB_BinaryOp binaryop); -extern GrB_Info GxB_BinaryOp_ytype(GrB_Type *ytype, GrB_BinaryOp binaryop); -extern GrB_Info GxB_BinaryOp_ztype(GrB_Type *ztype, GrB_BinaryOp binaryop); - -/* core */ -extern GrB_Info GxB_Global_Option_get(GxB_Option_Field field, ...); -extern GrB_Info GxB_Global_Option_set(GxB_Option_Field field, ...); -extern GrB_Info GxB_cuda_init(GrB_Mode mode); -extern GrB_Info GxB_init(GrB_Mode mode, void *(*user_malloc_function)(size_t), void *(*user_calloc_function)(size_t, size_t), void *(*user_realloc_function)(void *, size_t), void (*user_free_function)(void *), bool user_malloc_is_thread_safe); - -/* descriptor */ -extern GrB_Info GxB_Desc_get(GrB_Descriptor desc, GrB_Desc_Field field, ...); -extern GrB_Info GxB_Desc_set(GrB_Descriptor desc, GrB_Desc_Field field, ...); -extern GrB_Info GxB_Descriptor_fprint(GrB_Descriptor descriptor, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Descriptor_get(GrB_Desc_Value *val, GrB_Descriptor desc, GrB_Desc_Field field); - -/* matrix */ -extern GrB_Info GxB_Col_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_Option_get(GrB_Matrix A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Matrix_Option_set(GrB_Matrix A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Matrix_apply_BinaryOp1st(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GxB_Scalar x, const GrB_Matrix A, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_apply_BinaryOp2nd(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GxB_Scalar y, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_BitmapC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, GrB_Index *nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_BitmapR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, GrB_Index *nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_CSC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ai_size, GrB_Index *Ax_size, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_CSR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Aj_size, GrB_Index *Ax_size, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_FullC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, void **Ax, GrB_Index *Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_FullR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, void **Ax, GrB_Index *Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_HyperCSC(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ah_size, GrB_Index *Ai_size, GrB_Index *Ax_size, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_export_HyperCSR(GrB_Matrix *A, GrB_Type *type, GrB_Index *nrows, GrB_Index *ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Ah_size, GrB_Index *Aj_size, GrB_Index *Ax_size, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_fprint(GrB_Matrix A, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Matrix_import_BitmapC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, GrB_Index nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_BitmapR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, GrB_Index nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_CSC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ai_size, GrB_Index Ax_size, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_CSR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Aj_size, GrB_Index Ax_size, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_FullC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, void **Ax, GrB_Index Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_FullR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, void **Ax, GrB_Index Ax_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_HyperCSC(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ah_size, GrB_Index Ai_size, GrB_Index Ax_size, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_import_HyperCSR(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, GrB_Index **Ap, GrB_Index **Ah, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Ah_size, GrB_Index Aj_size, GrB_Index Ax_size, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_select(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GxB_SelectOp op, const GrB_Matrix A, const GxB_Scalar Thunk, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_subassign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); -extern GrB_Info GxB_Matrix_type(GrB_Type *type, const GrB_Matrix A); -extern GrB_Info GxB_Row_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); - -/* monoid */ -extern GrB_Info GxB_Monoid_fprint(GrB_Monoid monoid, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Monoid_identity(void *identity, GrB_Monoid monoid); -extern GrB_Info GxB_Monoid_operator(GrB_BinaryOp *op, GrB_Monoid monoid); -extern GrB_Info GxB_Monoid_terminal(bool *has_terminal, void *terminal, GrB_Monoid monoid); -extern GrB_Info GxB_Monoid_terminal_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, bool terminal); -extern GrB_Info GxB_Monoid_terminal_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, float terminal); -extern GrB_Info GxB_Monoid_terminal_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, double terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, int8_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, int16_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, int32_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, int64_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, void *terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, uint8_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, uint16_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, uint32_t terminal); -extern GrB_Info GxB_Monoid_terminal_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, uint64_t terminal); - -/* scalar */ -extern GrB_Info GxB_Scalar_clear(GxB_Scalar s); -extern GrB_Info GxB_Scalar_dup(GxB_Scalar *s, const GxB_Scalar t); -extern GrB_Info GxB_Scalar_error(const char **error, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_BOOL(bool *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_FP32(float *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_FP64(double *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT8(int8_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT16(int16_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT32(int32_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_INT64(int64_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UDT(void *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *x, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_fprint(GxB_Scalar s, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Scalar_free(GxB_Scalar *s); -extern GrB_Info GxB_Scalar_new(GxB_Scalar *s, GrB_Type type); -extern GrB_Info GxB_Scalar_nvals(GrB_Index *nvals, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_setElement_BOOL(GxB_Scalar s, bool x); -extern GrB_Info GxB_Scalar_setElement_FP32(GxB_Scalar s, float x); -extern GrB_Info GxB_Scalar_setElement_FP64(GxB_Scalar s, double x); -extern GrB_Info GxB_Scalar_setElement_INT8(GxB_Scalar s, int8_t x); -extern GrB_Info GxB_Scalar_setElement_INT16(GxB_Scalar s, int16_t x); -extern GrB_Info GxB_Scalar_setElement_INT32(GxB_Scalar s, int32_t x); -extern GrB_Info GxB_Scalar_setElement_INT64(GxB_Scalar s, int64_t x); -extern GrB_Info GxB_Scalar_setElement_UDT(GxB_Scalar s, void *x); -extern GrB_Info GxB_Scalar_setElement_UINT8(GxB_Scalar s, uint8_t x); -extern GrB_Info GxB_Scalar_setElement_UINT16(GxB_Scalar s, uint16_t x); -extern GrB_Info GxB_Scalar_setElement_UINT32(GxB_Scalar s, uint32_t x); -extern GrB_Info GxB_Scalar_setElement_UINT64(GxB_Scalar s, uint64_t x); -extern GrB_Info GxB_Scalar_type(GrB_Type *type, const GxB_Scalar s); -extern GrB_Info GxB_Scalar_wait(GxB_Scalar *s); - -/* selectop */ -extern GrB_Info GxB_SelectOp_error(const char **error, const GxB_SelectOp op); -extern GrB_Info GxB_SelectOp_fprint(GxB_SelectOp selectop, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_SelectOp_free(GxB_SelectOp *selectop); -extern GrB_Info GxB_SelectOp_new(GxB_SelectOp *selectop, GxB_select_function function, GrB_Type xtype, GrB_Type ttype); -extern GrB_Info GxB_SelectOp_ttype(GrB_Type *ttype, GxB_SelectOp selectop); -extern GrB_Info GxB_SelectOp_wait(GxB_SelectOp *op); -extern GrB_Info GxB_SelectOp_xtype(GrB_Type *xtype, GxB_SelectOp selectop); - -/* semiring */ -extern GrB_Info GxB_Semiring_add(GrB_Monoid *add, GrB_Semiring semiring); -extern GrB_Info GxB_Semiring_fprint(GrB_Semiring semiring, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Semiring_multiply(GrB_BinaryOp *multiply, GrB_Semiring semiring); - -/* type */ -extern GrB_Info GxB_Type_fprint(GrB_Type type, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Type_size(size_t *size, GrB_Type type); - -/* unary */ -extern GrB_Info GxB_UnaryOp_fprint(GrB_UnaryOp unaryop, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_UnaryOp_xtype(GrB_Type *xtype, GrB_UnaryOp unaryop); -extern GrB_Info GxB_UnaryOp_ztype(GrB_Type *ztype, GrB_UnaryOp unaryop); - -/* vector */ -extern GrB_Info GxB_Vector_Option_get(GrB_Vector A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Vector_Option_set(GrB_Vector A, GxB_Option_Field field, ...); -extern GrB_Info GxB_Vector_apply_BinaryOp1st(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GxB_Scalar x, const GrB_Vector u, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_apply_BinaryOp2nd(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const GxB_Scalar y, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_export_Bitmap(GrB_Vector *v, GrB_Type *type, GrB_Index *n, int8_t **vb, void **vx, GrB_Index *vb_size, GrB_Index *vx_size, GrB_Index *nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_export_CSC(GrB_Vector *v, GrB_Type *type, GrB_Index *n, GrB_Index **vi, void **vx, GrB_Index *vi_size, GrB_Index *vx_size, GrB_Index *nvals, bool *jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_export_Full(GrB_Vector *v, GrB_Type *type, GrB_Index *n, void **vx, GrB_Index *vx_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_fprint(GrB_Vector v, const char *name, GxB_Print_Level pr, FILE *f); -extern GrB_Info GxB_Vector_import_Bitmap(GrB_Vector *v, GrB_Type type, GrB_Index n, int8_t **vb, void **vx, GrB_Index vb_size, GrB_Index vx_size, GrB_Index nvals, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_import_CSC(GrB_Vector *v, GrB_Type type, GrB_Index n, GrB_Index **vi, void **vx, GrB_Index vi_size, GrB_Index vx_size, GrB_Index nvals, bool jumbled, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_import_Full(GrB_Vector *v, GrB_Type type, GrB_Index n, void **vx, GrB_Index vx_size, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_select(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GxB_SelectOp op, const GrB_Vector u, const GxB_Scalar Thunk, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_subassign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I, GrB_Index ni, const GrB_Descriptor desc); -extern GrB_Info GxB_Vector_type(GrB_Type *type, const GrB_Vector v); - -/* int DEFINES */ -#define GRB_SUBVERSION ... -#define GRB_VERSION ... -#define GxB_ANY_SPARSITY ... -#define GxB_AUTO_SPARSITY ... -#define GxB_BACKWARDS ... -#define GxB_BEGIN ... -#define GxB_BITMAP ... -#define GxB_CHUNK ... -#define GxB_END ... -#define GxB_FULL ... -#define GxB_GPU_CHUNK ... -#define GxB_GPU_CONTROL ... -#define GxB_HYPERSPARSE ... -#define GxB_IMPLEMENTATION ... -#define GxB_IMPLEMENTATION_MAJOR ... -#define GxB_IMPLEMENTATION_MINOR ... -#define GxB_IMPLEMENTATION_SUB ... -#define GxB_INC ... -#define GxB_INDEX_MAX ... -#define GxB_NBITMAP_SWITCH ... -#define GxB_NTHREADS ... -#define GxB_RANGE ... -#define GxB_SPARSE ... -#define GxB_SPEC_MAJOR ... -#define GxB_SPEC_MINOR ... -#define GxB_SPEC_SUB ... -#define GxB_SPEC_VERSION ... -#define GxB_STDC_VERSION ... -#define GxB_STRIDE ... - -/* char* DEFINES */ -extern char *GxB_IMPLEMENTATION_ABOUT_STR; -extern char *GxB_IMPLEMENTATION_DATE_STR; -extern char *GxB_IMPLEMENTATION_LICENSE_STR; -extern char *GxB_IMPLEMENTATION_NAME_STR; -extern char *GxB_SPEC_ABOUT_STR; -extern char *GxB_SPEC_DATE_STR; \ No newline at end of file diff --git a/suitesparse_graphblas/__init__.py b/suitesparse_graphblas/__init__.py new file mode 100644 index 0000000..48eac6c --- /dev/null +++ b/suitesparse_graphblas/__init__.py @@ -0,0 +1,339 @@ +"""Low-level Python CFFI binding for SuiteSparse:GraphBLAS.""" + +import importlib.metadata +import platform +import struct as _struct + +from . import exceptions as ex +from . import utils +from ._graphblas import ffi, lib + +_is_osx_arm64 = platform.machine() == "arm64" +_is_ppc64le = platform.machine() == "ppc64le" +_c_float = ffi.typeof("float") +_c_double = ffi.typeof("double") + +try: + __version__ = importlib.metadata.version("suitesparse-graphblas") +except Exception as exc: # pragma: no cover (safety) + raise AttributeError( + "`suitesparse_graphblas.__version__` not available. This may mean " + "suitesparse-graphblas was incorrectly installed or not installed at all. " + "For local development, you may want to do an editable install via " + "`python -m pip install -e path/to/suitesparse-graphblas`" + ) from exc +del importlib, platform + +# The SuiteSparse:GraphBLAS C library this binding was built against, as +# (major, minor, sub). ``__version__`` is the version of *this package*, +# which should normally match. +libgraphblas_version = ( + lib.GxB_IMPLEMENTATION_MAJOR, + lib.GxB_IMPLEMENTATION_MINOR, + lib.GxB_IMPLEMENTATION_SUB, +) + +# It is strongly recommended to use the non-variadic version of functions to be +# compatible with the most number of architectures. For example, you should use +# GxB_Matrix_Option_get_INT32 instead of GxB_Matrix_Option_get. +if _is_osx_arm64 or _is_ppc64le: + + def vararg(val): + # Interpret float as int32 and double as int64 + # https://devblogs.microsoft.com/oldnewthing/20220823-00/?p=107041 + tov = ffi.typeof(val) + if tov == _c_float: + val = _struct.unpack("l", _struct.pack("f", val))[0] + val = ffi.cast("int64_t", val) + elif tov == _c_double: + val = _struct.unpack("q", _struct.pack("d", val))[0] + val = ffi.cast("int64_t", val) + # Cast variadic argument as char * to force it onto the stack where ARM64 expects it + # https://developer.apple.com/documentation/xcode/writing-arm64-code-for-apple-platforms + # + # The same fix *may* work for ppc64le + return ffi.cast("char *", val) + +else: + + def vararg(val): + return val + + +def is_initialized(): + """Is GraphBLAS initialized via GrB_init or GxB_init?""" + mode = ffi.new("int32_t*") + return lib.GxB_Global_Option_get_INT32(lib.GxB_MODE, mode) != lib.GrB_PANIC + + +def supports_complex(): + """Does this package support complex numbers?""" + return hasattr(lib, "GrB_FC64") or hasattr(lib, "GxB_FC64") + + +def initialize(*, blocking=False, memory_manager="numpy"): + """Initialize GraphBLAS via GrB_init or GxB_init. + + This must be called before any other GraphBLAS functions are called. + A RuntimeError will be raised if called more than once. + + Parameters + ---------- + blocking : bool, optional + Whether to call init with GrB_BLOCKING or GrB_NONBLOCKING. + Default is False. + memory_manager : {'numpy', 'c'}, optional + Choose which malloc/free functions GraphBLAS uses. 'numpy' uses NumPy's + allocator, so arrays NumPy allocated can be handed to GraphBLAS without + copying, and Python can track memory usage via tracemalloc (if enabled). + 'c' uses the C library's. Either way, `suitesparse_graphblas.utils` moves + buffers between GraphBLAS and NumPy safely, copying when it must. + Default is 'numpy'. + + The global variable `suitesparse_graphblas.is_initialized` indicates whether + GraphBLAS has been initialized. + """ + if is_initialized(): + raise RuntimeError("GraphBLAS is already initialized! Unable to initialize again.") + blocking = lib.GrB_BLOCKING if blocking else lib.GrB_NONBLOCKING + memory_manager = memory_manager.lower() + if memory_manager == "numpy": + info = utils.call_gxb_init(ffi, lib, blocking) + elif memory_manager == "c": + info = lib.GrB_init(blocking) + else: + raise ValueError(f'memory_manager argument must be "numpy" or "c"; got: {memory_manager!r}') + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"Failed to initialize GraphBLAS (info={info})" + ) + # See: https://github.com/GraphBLAS/python-suitesparse-graphblas/issues/40 + for attr in dir(lib): + getattr(lib, attr) + + +def libget(name): + """Helper to get items from GraphBLAS which might be GrB or GxB""" + try: + return getattr(lib, name) + except AttributeError: + ext_name = f"GxB_{name[4:]}" + try: + return getattr(lib, ext_name) + except AttributeError: + pass + raise + + +bool_types = frozenset((lib.GrB_BOOL,)) + +signed_integer_types = frozenset( + ( + lib.GrB_INT8, + lib.GrB_INT16, + lib.GrB_INT32, + lib.GrB_INT64, + ) +) + +unsigned_integer_types = frozenset( + ( + lib.GrB_UINT8, + lib.GrB_UINT16, + lib.GrB_UINT32, + lib.GrB_UINT64, + ) +) + +integer_types = signed_integer_types | unsigned_integer_types + +real_types = frozenset( + ( + lib.GrB_FP32, + lib.GrB_FP64, + ) +) + +if supports_complex(): + complex_types = frozenset( + ( + lib.GxB_FC32, + lib.GxB_FC64, + ) + ) +else: + complex_types = frozenset() + + +grb_types = bool_types | integer_types | real_types | complex_types + + +_error_code_lookup = { + # Warning + lib.GrB_NO_VALUE: ex.NoValue, + # API Errors + lib.GrB_UNINITIALIZED_OBJECT: ex.UninitializedObject, + lib.GrB_INVALID_OBJECT: ex.InvalidObject, + lib.GrB_NULL_POINTER: ex.NullPointer, + lib.GrB_INVALID_VALUE: ex.InvalidValue, + lib.GrB_INVALID_INDEX: ex.InvalidIndex, + lib.GrB_DOMAIN_MISMATCH: ex.DomainMismatch, + lib.GrB_DIMENSION_MISMATCH: ex.DimensionMismatch, + lib.GrB_OUTPUT_NOT_EMPTY: ex.OutputNotEmpty, + lib.GrB_EMPTY_OBJECT: ex.EmptyObject, + # Execution Errors + lib.GrB_OUT_OF_MEMORY: ex.OutOfMemory, + lib.GrB_INSUFFICIENT_SPACE: ex.InsufficientSpace, + lib.GrB_INDEX_OUT_OF_BOUNDS: ex.IndexOutOfBound, + lib.GrB_PANIC: ex.Panic, + lib.GrB_NOT_IMPLEMENTED: ex.NotImplementedException, + # GxB Errors + lib.GxB_EXHAUSTED: StopIteration, + lib.GxB_JIT_ERROR: ex.JitError, +} +GrB_SUCCESS = lib.GrB_SUCCESS +GrB_NO_VALUE = lib.GrB_NO_VALUE + + +_error_func_lookup = { + "struct GB_Type_opaque *": lib.GrB_Type_error, + "struct GB_UnaryOp_opaque *": lib.GrB_UnaryOp_error, + "struct GB_BinaryOp_opaque *": lib.GrB_BinaryOp_error, + "struct GB_Monoid_opaque *": lib.GrB_Monoid_error, + "struct GB_Semiring_opaque *": lib.GrB_Semiring_error, + "struct GB_Scalar_opaque *": lib.GxB_Scalar_error, + "struct GB_Matrix_opaque *": lib.GrB_Matrix_error, + "struct GB_Vector_opaque *": lib.GrB_Vector_error, + "struct GB_Descriptor_opaque *": lib.GrB_Descriptor_error, + "struct GB_Context_opaque *": lib.GxB_Context_error, + "struct GB_IndexUnaryOp_opaque *": lib.GrB_IndexUnaryOp_error, + "struct GB_IndexBinaryOp_opaque *": lib.GxB_IndexBinaryOp_error, +} + + +def check_status(obj, response_code): + """Check the return code of the GraphBLAS function. + + If the operation was successful, return None. + + If the operation returned no value return `exceptions.NoValue`. + + Otherwise it is an error, lookup the exception and the error + description, and throw the exception. + + """ + if response_code == GrB_SUCCESS: + return + if response_code == GrB_NO_VALUE: + return ex.NoValue + + if ffi.typeof(obj).item.kind == "pointer": + obj = obj[0] + + cname = ffi.typeof(obj).cname + error_func = _error_func_lookup.get(cname) + if error_func is None: + raise TypeError(f"Unknown cname {cname} looking up error string.") + + string = ffi.new("char**") + error_func(string, obj) + text = ffi.string(string[0]).decode() + raise _error_code_lookup[response_code](text) + + +class burble: + """Control diagnostic output, and may be used as a context manager. + + Set up and simple usage: + + >>> from suitesparse_graphblas import burble, lib, matrix + >>> + >>> A = matrix.matrix_new(lib.GrB_BOOL, 3, 3) + >>> burble.is_enabled + False + >>> burble.enable() + >>> burble.is_enabled + True + >>> burble.disable() + + Example with explicit enable and disable: + + >>> burble.enable() + >>> n = matrix.matrix_nvals(A) + [ GrB_Matrix_nvals + 1.91e-06 sec ] + >>> burble.disable() + + Example as a context manager: + + >>> with burble(): + >>> n = matrix.matrix_nvals(A) + [ GrB_Matrix_nvals + 1.91e-06 sec ] + + """ + + def __init__(self): + self._states = [] + + @property + def is_enabled(self): + """Is burble enabled?""" + val_ptr = ffi.new("int32_t*") + info = lib.GxB_Global_Option_get_INT32(lib.GxB_BURBLE, val_ptr) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup[info]( + "Failed to get burble status (has GraphBLAS been initialized?" + ) + return val_ptr[0] + + def enable(self): + """Enable diagnostic output""" + info = lib.GxB_Global_Option_set_INT32(lib.GxB_BURBLE, ffi.cast("int32_t", 1)) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup[info]( + "Failed to enable burble (has GraphBLAS been initialized?" + ) + + def disable(self): + """Disable diagnostic output""" + info = lib.GxB_Global_Option_set_INT32(lib.GxB_BURBLE, ffi.cast("int32_t", 0)) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup[info]( + "Failed to disable burble (has GraphBLAS been initialized?" + ) + + def __enter__(self): + is_enabled = self.is_enabled + if not is_enabled: + self.enable() + self._states.append(is_enabled) + return self + + def __exit__(self, type_, value, traceback): + is_enabled = self._states.pop() + if not is_enabled: + self.disable() + + def __reduce__(self): + return "burble" + + def __repr__(self): + return f"" + + +burble = burble() + +# isort: off +# Backward-compatible re-exports: functional API moved to suitesparse_graphblas.api. +# These must stay at the bottom of the file: the api modules import names defined +# above (`check_status`, `ffi`, `lib`), so letting isort's `float_to_top` hoist them +# to the top would make `import suitesparse_graphblas` a circular import. +from suitesparse_graphblas.api import iterator, matrix, scalar, vector # noqa: E402, F401 +from suitesparse_graphblas.api.global_options import ( # noqa: E402, F401 + global_option_get_char, + global_option_get_fp64, + global_option_get_int32, + global_option_set_fp64, + global_option_set_int32, +) diff --git a/suitesparse_graphblas/api/__init__.py b/suitesparse_graphblas/api/__init__.py new file mode 100644 index 0000000..3006c1f --- /dev/null +++ b/suitesparse_graphblas/api/__init__.py @@ -0,0 +1,42 @@ +"""[SuiteSparse:GraphBLAS](https://github.com/DrTimothyAldenDavis/GraphBLAS) +is a full implementation of the GraphBLAS standard, which defines a +set of sparse matrix operations on an extended algebra of semirings +using an almost unlimited variety of operators and types. When applied +to sparse adjacency matrices, these algebraic operations are +equivalent to computations on graphs. GraphBLAS provides a powerful +and expressive framework for creating high-performance graph +algorithms based on the elegant mathematics of sparse matrix +operations on a semiring. + +This module contains the "functional API" for +python-suitesparse-graphblas. This is a higher level API than the +"raw" CFFI binding, but a lower level API than the algebraic +functionality provided by the +[python-graphblas](https://python-graphblas.readthedocs.io/en/stable/api_reference/index.html) +library. + +For documentation on the SuiteSparse implementation that describes all +of these functions in detail, read the [SuiteSparse:GraphBLAS User +Guide](https://github.com/DrTimothyAldenDavis/GraphBLAS/blob/stable/Doc/GraphBLAS_UserGuide.pdf) + +""" + +from suitesparse_graphblas.api import io # noqa: F401 +from suitesparse_graphblas.api import ( + binaryop, + container, + context, + descriptor, + global_options, + grb_type, + indexbinaryop, + indexunaryop, + iterator, + matrix, + monoid, + scalar, + selectop, + semiring, + unaryop, + vector, +) diff --git a/suitesparse_graphblas/api/binaryop.py b/suitesparse_graphblas/api/binaryop.py new file mode 100644 index 0000000..cc87358 --- /dev/null +++ b/suitesparse_graphblas/api/binaryop.py @@ -0,0 +1,280 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def binaryop_free(op): + """Free a binary operator. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_free(op) + + """ + check_status(op, lib.GrB_BinaryOp_free(op)) + + +def binaryop_new(function, ztype, xtype, ytype, *, free=binaryop_free): + """Create a new GrB_BinaryOp from a C function pointer. + + ``function`` must be a CFFI callback compatible with + ``GxB_binary_function``. + + The ``free`` argument is called when the object is garbage + collected, the default is ``binaryop.binaryop_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the operator. + """ + op = ffi.new("GrB_BinaryOp*") + check_status(op, lib.GrB_BinaryOp_new(op, function, ztype, xtype, ytype)) + if free: + return ffi.gc(op, free) + return op + + +def binaryop_new_named(function, ztype, xtype, ytype, name, defn, *, free=binaryop_free): + """Create a new named GrB_BinaryOp (GxB extension). + + ``function`` must be a CFFI callback compatible with + ``GxB_binary_function``. ``name`` and ``defn`` are C strings + describing the operator for JIT compilation. + + The ``free`` argument is called when the object is garbage + collected, the default is ``binaryop.binaryop_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the operator. + """ + op = ffi.new("GrB_BinaryOp*") + check_status( + op, + lib.GxB_BinaryOp_new( + op, + function, + ztype, + xtype, + ytype, + name.encode() if isinstance(name, str) else name, + defn.encode() if isinstance(defn, str) else defn, + ), + ) + if free: + return ffi.gc(op, free) + return op + + +def binaryop_new_indexop(idxbinop, theta, *, free=binaryop_free): + """Create a new GrB_BinaryOp from a GxB_IndexBinaryOp and a scalar theta. + + The ``free`` argument is called when the object is garbage + collected, the default is ``binaryop.binaryop_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the operator. + """ + op = ffi.new("GrB_BinaryOp*") + check_status(op, lib.GxB_BinaryOp_new_IndexOp(op, idxbinop, theta)) + if free: + return ffi.gc(op, free) + return op + + +def binaryop_wait(op, waitmode=lib.GrB_COMPLETE): + """Wait for a binary operator to complete pending operations. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_wait(op) + + """ + check_status(op, lib.GrB_BinaryOp_wait(op[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def binaryop_print(op, name="", level=lib.GxB_COMPLETE): + """Print a binary operator to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> out = _capture_c_output(binaryop_print, op, 'op', lib.GxB_SHORT) + >>> 'plus' in out.lower() + True + + """ + check_status( + op, + lib.GxB_BinaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def binaryop_fprint(op, f, name="", level=lib.GxB_COMPLETE): + """Print a binary operator to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`binaryop_print`). + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> out = _capture_c_output(binaryop_fprint, op, ffi.NULL, 'op', lib.GxB_SHORT) + >>> 'plus' in out.lower() + True + + """ + check_status( + op, + lib.GxB_BinaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def binaryop_get_int32(op, field): + """Get an operator option as an int32. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_get_int32(op, lib.GrB_OUTP_TYPE_CODE) >= 0 + True + + """ + val = ffi.new("int32_t*") + check_status(op, lib.GrB_BinaryOp_get_INT32(op[0], val, field)) + return val[0] + + +def binaryop_set_int32(op, field, value): + """Set an operator option from an int32.""" + check_status(op, lib.GrB_BinaryOp_set_INT32(op[0], ffi.cast("int32_t", value), field)) + + +def binaryop_get_size(op, field): + """Get an operator option as a size_t. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_get_size(op, lib.GrB_NAME) > 0 + True + + """ + val = ffi.new("size_t*") + check_status(op, lib.GrB_BinaryOp_get_SIZE(op[0], val, field)) + return val[0] + + +def binaryop_get_string(op, field): + """Get an operator option as a string. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> 'plus' in binaryop_get_string(op, lib.GrB_NAME).lower() + True + + """ + val = ffi.new("char[256]") + check_status(op, lib.GrB_BinaryOp_get_String(op[0], val, field)) + return ffi.string(val).decode() + + +def binaryop_set_string(op, field, value): + """Set an operator option from a string.""" + check_status( + op, + lib.GrB_BinaryOp_set_String( + op[0], value.encode() if isinstance(value, str) else value, field + ), + ) + + +# --------------------------------------------------------------------------- +# Type queries +# --------------------------------------------------------------------------- + + +def binaryop_xtype(op): + """Return the first input (x) type of a binary operator. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_xtype(op) == lib.GrB_INT64 + True + + """ + T = ffi.new("GrB_Type*") + check_status(op, lib.GxB_BinaryOp_xtype(T, op[0])) + return T[0] + + +def binaryop_ytype(op): + """Return the second input (y) type of a binary operator. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_ytype(op) == lib.GrB_INT64 + True + + """ + T = ffi.new("GrB_Type*") + check_status(op, lib.GxB_BinaryOp_ytype(T, op[0])) + return T[0] + + +def binaryop_ztype(op): + """Return the output (z) type of a binary operator. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_ztype(op) == lib.GrB_INT64 + True + + """ + T = ffi.new("GrB_Type*") + check_status(op, lib.GxB_BinaryOp_ztype(T, op[0])) + return T[0] + + +def binaryop_xtype_name(op): + """Return the first input (x) type name of a binary operator as a string. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_xtype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_BinaryOp_xtype_name(name, op[0])) + return ffi.string(name).decode() + + +def binaryop_ytype_name(op): + """Return the second input (y) type name of a binary operator as a string. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_ytype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_BinaryOp_ytype_name(name, op[0])) + return ffi.string(name).decode() + + +def binaryop_ztype_name(op): + """Return the output (z) type name of a binary operator as a string. + + >>> op = ffi.new("GrB_BinaryOp*", lib.GrB_PLUS_INT64) + >>> binaryop_ztype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_BinaryOp_ztype_name(name, op[0])) + return ffi.string(name).decode() diff --git a/suitesparse_graphblas/api/container.py b/suitesparse_graphblas/api/container.py new file mode 100644 index 0000000..2418f0a --- /dev/null +++ b/suitesparse_graphblas/api/container.py @@ -0,0 +1,37 @@ +from suitesparse_graphblas import _error_code_lookup, ffi, lib + + +def container_free(c): + """Free a container. + + >>> c = container_new() + >>> container_free(c) + + """ + info = lib.GxB_Container_free(c) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Container_free failed with info={info}" + ) + + +def container_new(*, free=container_free): + """Create a new ``GxB_Container`` and initialize it. + + The ``free`` argument is called when the object is garbage + collected, the default is ``container.container_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the container. + + >>> c = container_new() + + """ + c = ffi.new("GxB_Container*") + info = lib.GxB_Container_new(c) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Container_new failed with info={info}" + ) + if free: + return ffi.gc(c, free) + return c diff --git a/suitesparse_graphblas/api/context.py b/suitesparse_graphblas/api/context.py new file mode 100644 index 0000000..5549bd5 --- /dev/null +++ b/suitesparse_graphblas/api/context.py @@ -0,0 +1,235 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def context_free(ctx): + """Free a context. + + >>> ctx = context_new() + >>> context_free(ctx) + + """ + check_status(ctx, lib.GxB_Context_free(ctx)) + + +def context_new(*, free=context_free): + """Create a new GxB_Context and initialize it. + + The ``free`` argument is called when the object is garbage + collected, the default is ``context.context_free()``. If ``free`` is None + then there is no automatic garbage collection and it is up to the user + to free the context. + + >>> ctx = context_new() + + """ + ctx = ffi.new("GxB_Context*") + check_status(ctx, lib.GxB_Context_new(ctx)) + if free: + return ffi.gc(ctx, free) + return ctx + + +def context_wait(ctx, waitmode=lib.GrB_COMPLETE): + """Wait for a context to complete pending operations. + + >>> ctx = context_new() + >>> context_wait(ctx) + + """ + check_status(ctx, lib.GxB_Context_wait(ctx[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Engage / disengage +# --------------------------------------------------------------------------- + + +def context_engage(ctx): + """Engage a context for the calling thread. + + An engaged context controls settings like nthreads and chunk for all + GraphBLAS operations executed by the calling thread until the context + is disengaged. + + >>> ctx = context_new() + >>> context_engage(ctx) + >>> context_disengage(ctx) + + """ + check_status(ctx, lib.GxB_Context_engage(ctx[0])) + + +def context_disengage(ctx): + """Disengage a context from the calling thread. + + After disengaging, the calling thread reverts to the default + (world) context settings. + + >>> ctx = context_new() + >>> context_engage(ctx) + >>> context_disengage(ctx) + + """ + check_status(ctx, lib.GxB_Context_disengage(ctx[0])) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def context_get_int32(ctx, field): + """Get a context option as an int32. + + >>> ctx = context_new() + >>> context_get_int32(ctx, lib.GxB_CONTEXT_NTHREADS) >= 0 + True + + """ + val = ffi.new("int32_t*") + check_status(ctx, lib.GxB_Context_get_INT32(ctx[0], field, val)) + return val[0] + + +def context_set_int32(ctx, field, value): + """Set a context option from an int32. + + >>> ctx = context_new() + >>> context_set_int32(ctx, lib.GxB_CONTEXT_NTHREADS, 2) + >>> context_get_int32(ctx, lib.GxB_CONTEXT_NTHREADS) + 2 + + """ + check_status(ctx, lib.GxB_Context_set_INT32(ctx[0], field, ffi.cast("int32_t", value))) + + +def context_get_fp64(ctx, field): + """Get a context option as a float64. + + >>> ctx = context_new() + >>> isinstance(context_get_fp64(ctx, lib.GxB_CONTEXT_CHUNK), float) + True + + """ + val = ffi.new("double*") + check_status(ctx, lib.GxB_Context_get_FP64(ctx[0], field, val)) + return val[0] + + +def context_set_fp64(ctx, field, value): + """Set a context option from a float64. + + >>> ctx = context_new() + >>> context_set_fp64(ctx, lib.GxB_CONTEXT_CHUNK, 4096.0) + >>> context_get_fp64(ctx, lib.GxB_CONTEXT_CHUNK) + 4096.0 + + """ + check_status(ctx, lib.GxB_Context_set_FP64(ctx[0], field, ffi.cast("double", value))) + + +# --------------------------------------------------------------------------- +# Convenience accessors +# --------------------------------------------------------------------------- + + +def context_get_nthreads(ctx): + """Get the number of threads for a context. + + >>> ctx = context_new() + >>> context_get_nthreads(ctx) >= 0 + True + + """ + return context_get_int32(ctx, lib.GxB_CONTEXT_NTHREADS) + + +def context_set_nthreads(ctx, nthreads): + """Set the number of threads for a context. + + >>> ctx = context_new() + >>> context_set_nthreads(ctx, 4) + >>> context_get_nthreads(ctx) + 4 + + """ + context_set_int32(ctx, lib.GxB_CONTEXT_NTHREADS, nthreads) + + +def context_get_chunk(ctx): + """Get the chunk size for a context. + + The chunk size determines the minimum amount of work per thread. + + >>> ctx = context_new() + >>> isinstance(context_get_chunk(ctx), float) + True + + """ + return context_get_fp64(ctx, lib.GxB_CONTEXT_CHUNK) + + +def context_set_chunk(ctx, chunk): + """Set the chunk size for a context. + + >>> ctx = context_new() + >>> context_set_chunk(ctx, 4096.0) + >>> context_get_chunk(ctx) + 4096.0 + + """ + context_set_fp64(ctx, lib.GxB_CONTEXT_CHUNK, chunk) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def context_print(ctx, name="", level=lib.GxB_COMPLETE): + """Print a context to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> ctx = context_new() + >>> out = _capture_c_output(context_print, ctx, 'ctx', lib.GxB_SHORT) + >>> 'Context' in out + True + + """ + check_status( + ctx, + lib.GxB_Context_fprint( + ctx[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def context_fprint(ctx, f, name="", level=lib.GxB_COMPLETE): + """Print a context to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`context_print`). + + >>> ctx = context_new() + >>> out = _capture_c_output(context_fprint, ctx, ffi.NULL, 'ctx', lib.GxB_SHORT) + >>> 'Context' in out + True + + """ + check_status( + ctx, + lib.GxB_Context_fprint( + ctx[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) diff --git a/suitesparse_graphblas/api/descriptor.py b/suitesparse_graphblas/api/descriptor.py new file mode 100644 index 0000000..308a071 --- /dev/null +++ b/suitesparse_graphblas/api/descriptor.py @@ -0,0 +1,126 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def descriptor_wait(desc, waitmode=lib.GrB_COMPLETE): + """Wait for a descriptor to complete pending operations. + + >>> descriptor_wait(lib.GrB_DESC_S) + + """ + check_status(desc, lib.GrB_Descriptor_wait(desc, waitmode)) + + +def descriptor_print(desc, name="", level=lib.GxB_COMPLETE): + """Print a descriptor to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> out = _capture_c_output(descriptor_print, lib.GrB_DESC_S, 'desc', lib.GxB_SHORT) + >>> 'Descriptor' in out + True + + """ + check_status( + desc, + lib.GxB_Descriptor_fprint( + desc, + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def descriptor_fprint(desc, f, name="", level=lib.GxB_COMPLETE): + """Print a descriptor to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`descriptor_print`). + + >>> out = _capture_c_output(descriptor_fprint, lib.GrB_DESC_S, ffi.NULL, 'desc', lib.GxB_SHORT) + >>> 'Descriptor' in out + True + + """ + check_status( + desc, + lib.GxB_Descriptor_fprint( + desc, + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Get / Set +# --------------------------------------------------------------------------- + + +def descriptor_get_int32(desc, field): + """Get a descriptor property as an int32. + + >>> isinstance(descriptor_get_int32(lib.GrB_DESC_S, lib.GrB_OUTP_FIELD), int) + True + + """ + val = ffi.new("int32_t*") + check_status(desc, lib.GrB_Descriptor_get_INT32(desc, val, field)) + return val[0] + + +def descriptor_set_int32(desc, field, value): + """Set a descriptor property from an int32. + + >>> from suitesparse_graphblas.api.descriptor import descriptor_get_int32 + >>> descriptor_get_int32(lib.GrB_DESC_S, lib.GrB_OUTP_FIELD) == lib.GrB_REPLACE + False + + """ + check_status( + desc, + lib.GrB_Descriptor_set_INT32( + desc, + ffi.cast("int32_t", value), + field, + ), + ) + + +def descriptor_get_size(desc, field): + """Get a descriptor property as a size_t. + + >>> isinstance(descriptor_get_size(lib.GrB_DESC_S, lib.GrB_NAME), int) + True + + """ + val = ffi.new("size_t*") + check_status(desc, lib.GrB_Descriptor_get_SIZE(desc, val, field)) + return val[0] + + +def descriptor_get_string(desc, field): + """Get a descriptor property as a string. + + >>> isinstance(descriptor_get_string(lib.GrB_DESC_S, lib.GrB_NAME), str) + True + + """ + val = ffi.new("char[256]") + check_status(desc, lib.GrB_Descriptor_get_String(desc, val, field)) + return ffi.string(val).decode() + + +def descriptor_set_string(desc, field, value): + """Set a descriptor property from a string. + + >>> descriptor_get_string(lib.GrB_DESC_S, lib.GrB_NAME) + 'GrB_DESC_S' + + """ + check_status(desc, lib.GrB_Descriptor_set_String(desc, value.encode(), field)) diff --git a/suitesparse_graphblas/api/examples/__init__.py b/suitesparse_graphblas/api/examples/__init__.py new file mode 100644 index 0000000..6f05b2f --- /dev/null +++ b/suitesparse_graphblas/api/examples/__init__.py @@ -0,0 +1,7 @@ +"""Example graph algorithms using the functional API. + +These examples are Python translations of algorithms from the +[LAGraph](https://github.com/GraphBLAS/LAGraph) library, demonstrating +how to use the `suitesparse_graphblas.api` modules to implement +graph algorithms with GraphBLAS. +""" diff --git a/suitesparse_graphblas/api/examples/bfs.py b/suitesparse_graphblas/api/examples/bfs.py new file mode 100644 index 0000000..feb122c --- /dev/null +++ b/suitesparse_graphblas/api/examples/bfs.py @@ -0,0 +1,173 @@ +"""Breadth-First Search using the GraphBLAS functional API. + +This is a Python translation of the vanilla (push-only) BFS algorithm from +[LAGraph](https://github.com/GraphBLAS/LAGraph) +(`LG_BreadthFirstSearch_vanilla_template.c`). + +The algorithm uses vector-matrix multiply (`vxm`) with a structural +complement mask to expand the frontier to unvisited nodes at each level. +It can compute BFS levels (distances from source), parent node IDs in +the BFS tree, or both. + +Example +------- +Build a small directed graph and run BFS from node 0:: + + >>> from suitesparse_graphblas import lib + >>> from suitesparse_graphblas.api import matrix, vector + >>> from suitesparse_graphblas.api.examples.bfs import bfs + >>> # + >>> # Graph: 0 -> 1 -> 2 -> 3 + >>> A = matrix.matrix_new(lib.GrB_BOOL, 4, 4) + >>> matrix.set_bool(A, True, 0, 1) + >>> matrix.set_bool(A, True, 1, 2) + >>> matrix.set_bool(A, True, 2, 3) + >>> level, parent = bfs(A, 0) + >>> [vector.get_int64(level, i) for i in range(4)] + [0, 1, 2, 3] + >>> [vector.get_int64(parent, i) for i in range(4)] + [0, 0, 1, 2] +""" + +from suitesparse_graphblas import lib +from suitesparse_graphblas.api import matrix, scalar, vector + + +def bfs(A, src, compute_level=True, compute_parent=True): + """Breadth-first search on a graph represented as an adjacency matrix. + + Parameters + ---------- + A : GrB_Matrix* + Square adjacency matrix (any type). Edge from ``i`` to ``j`` + exists when ``A(i, j)`` is stored. + src : int + Source node index (0-based). + compute_level : bool + If True, return a level vector where ``level(i)`` is the + shortest-path distance from *src* to node *i*. + compute_parent : bool + If True, return a parent vector where ``parent(i)`` is the + parent of node *i* in the BFS tree (``parent(src) == src``). + + Returns + ------- + level : GrB_Vector* or None + Level vector (if *compute_level* is True). + parent : GrB_Vector* or None + Parent vector (if *compute_parent* is True). + """ + if not compute_level and not compute_parent: + raise ValueError("at least one of compute_level or compute_parent must be True") + + n = matrix.matrix_nrows(A) + + if compute_parent: + # Parent mode: frontier is INT64, holds parent IDs. + # Semiring: MIN_FIRST selects the minimum parent index. + parent_vec = vector.vector_new(lib.GrB_INT64, n) + semiring = lib.GrB_MIN_FIRST_SEMIRING_INT64 + frontier = vector.vector_new(lib.GrB_INT64, n) + vector.set_int64(frontier, src, src) + index_thunk = scalar.scalar_new(lib.GrB_INT64) + scalar.set_int64(index_thunk, 0) + else: + # Level-only mode: frontier is BOOL. + # Semiring: ANY_PAIR just checks reachability. + parent_vec = None + semiring = lib.GxB_ANY_PAIR_BOOL + frontier = vector.vector_new(lib.GrB_BOOL, n) + vector.set_bool(frontier, True, src) + + level_vec = vector.vector_new(lib.GrB_INT64, n) if compute_level else None + + # The mask is the set of already-visited nodes (parent or level vector). + # GrB_DESC_RSC complements the mask so vxm only writes to unvisited nodes. + mask = parent_vec if compute_parent else level_vec + + # Scalar used to assign the current level number. + if compute_level: + level_scalar = scalar.scalar_new(lib.GrB_INT64) + + current_level = 0 + while True: + # Assign current level to all frontier nodes: level = current_level + if compute_level: + scalar.set_int64(level_scalar, current_level) + vector.vector_assign_scalar( + level_vec, + level_scalar, + lib.GrB_ALL, + n, + mask=frontier, + desc=lib.GrB_DESC_S, + ) + + if compute_parent: + # Record parent IDs: parent = frontier + vector.vector_assign( + parent_vec, + frontier, + lib.GrB_ALL, + n, + mask=frontier, + desc=lib.GrB_DESC_S, + ) + # Convert frontier values to their own indices (ROWINDEX). + # After this, frontier(i) == i for every stored entry, + # so the next vxm propagates node i as the parent ID. + vector.vector_apply_indexop( + frontier, + lib.GrB_ROWINDEX_INT64, + frontier, + index_thunk, + ) + + current_level += 1 + + # Expand frontier: frontier = frontier * A + vector.vector_vxm( + frontier, + semiring, + frontier, + A, + mask=mask, + desc=lib.GrB_DESC_RSC, + ) + + # Stop when the frontier is empty. + if vector.vector_nvals(frontier) == 0: + break + + return level_vec, parent_vec + + +if __name__ == "__main__": + import suitesparse_graphblas as gb + + gb.initialize() + + # Build a small undirected graph (7 nodes): + # + # 0 --- 1 --- 2 + # | | + # 3 4 --- 5 + # | + # 6 + # + n = 7 + A = matrix.matrix_new(lib.GrB_BOOL, n, n) + edges = [(0, 1), (0, 3), (1, 2), (1, 4), (4, 5), (4, 6)] + for i, j in edges: + matrix.set_bool(A, True, i, j) + matrix.set_bool(A, True, j, i) # undirected + + src = 0 + level, parent = bfs(A, src) + + print(f"BFS from node {src}:") + print(f" {'node':>4} {'level':>5} {'parent':>6}") + for i in range(n): + lv = vector.get_int64(level, i) + pa = vector.get_int64(parent, i) + print(f" {i:>4} {lv:>5} {pa:>6}") diff --git a/suitesparse_graphblas/api/global_options.py b/suitesparse_graphblas/api/global_options.py new file mode 100644 index 0000000..85224e4 --- /dev/null +++ b/suitesparse_graphblas/api/global_options.py @@ -0,0 +1,147 @@ +from suitesparse_graphblas import _error_code_lookup, ffi, lib + + +def global_option_get_int32(field): + """Get a global option as an int32. + + >>> global_option_get_int32(lib.GxB_BURBLE) in (0, 1) + True + + """ + val = ffi.new("int32_t*") + info = lib.GxB_Global_Option_get_INT32(field, val) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Global_Option_get_INT32 failed with info={info}" + ) + return val[0] + + +def global_option_set_int32(field, value): + """Set a global option from an int32. + + >>> global_option_set_int32(lib.GxB_BURBLE, 0) + + """ + info = lib.GxB_Global_Option_set_INT32(field, ffi.cast("int32_t", value)) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Global_Option_set_INT32 failed with info={info}" + ) + + +def global_option_get_fp64(field): + """Get a global option as a float64. + + >>> isinstance(global_option_get_fp64(lib.GxB_HYPER_SWITCH), float) + True + + """ + val = ffi.new("double*") + info = lib.GxB_Global_Option_get_FP64(field, val) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Global_Option_get_FP64 failed with info={info}" + ) + return val[0] + + +def global_option_set_fp64(field, value): + """Set a global option from a float64. + + >>> default = global_option_get_fp64(lib.GxB_HYPER_SWITCH) + >>> global_option_set_fp64(lib.GxB_HYPER_SWITCH, default) + + """ + info = lib.GxB_Global_Option_set_FP64(field, ffi.cast("double", value)) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Global_Option_set_FP64 failed with info={info}" + ) + + +def global_option_get_char(field): + """Get a global option as a string. + + >>> 'SuiteSparse:GraphBLAS' in global_option_get_char(lib.GxB_LIBRARY_NAME) + True + + """ + val = ffi.new("char**") + info = lib.GxB_Global_Option_get_CHAR(field, val) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_Global_Option_get_CHAR failed with info={info}" + ) + return ffi.string(val[0]).decode() + + +def global_get_int32(field): + """Get a global property as an int32. + + >>> isinstance(global_get_int32(lib.GxB_NTHREADS), int) + True + + """ + val = ffi.new("int32_t*") + info = lib.GrB_Global_get_INT32(lib.GrB_GLOBAL, val, field) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GrB_Global_get_INT32 failed with info={info}" + ) + return val[0] + + +def global_set_int32(field, value): + """Set a global property from an int32. + + >>> nthreads = global_get_int32(lib.GxB_NTHREADS) + >>> global_set_int32(lib.GxB_NTHREADS, nthreads) + + """ + info = lib.GrB_Global_set_INT32(lib.GrB_GLOBAL, ffi.cast("int32_t", value), field) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GrB_Global_set_INT32 failed with info={info}" + ) + + +def global_get_size(field): + """Get a global property as a size_t. + + >>> isinstance(global_get_size(lib.GrB_NAME), int) + True + + """ + val = ffi.new("size_t*") + info = lib.GrB_Global_get_SIZE(lib.GrB_GLOBAL, val, field) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GrB_Global_get_SIZE failed with info={info}" + ) + return val[0] + + +def global_get_string(field): + """Get a global property as a string. + + >>> 'SuiteSparse:GraphBLAS' in global_get_string(lib.GrB_NAME) + True + + """ + val = ffi.new("char[256]") + info = lib.GrB_Global_get_String(lib.GrB_GLOBAL, val, field) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GrB_Global_get_String failed with info={info}" + ) + return ffi.string(val).decode() + + +def global_set_string(field, value): + """Set a global property from a string.""" + info = lib.GrB_Global_set_String(lib.GrB_GLOBAL, value.encode(), field) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GrB_Global_set_String failed with info={info}" + ) diff --git a/suitesparse_graphblas/api/grb_type.py b/suitesparse_graphblas/api/grb_type.py new file mode 100644 index 0000000..1c01fc3 --- /dev/null +++ b/suitesparse_graphblas/api/grb_type.py @@ -0,0 +1,208 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def grb_type_free(T): + """Free a type. + + >>> T = grb_type_new(8) + >>> grb_type_free(T) + + """ + check_status(T, lib.GrB_Type_free(T)) + + +def grb_type_new(sizeof_ctype, *, free=grb_type_free): + """Create a new ``GrB_Type`` and initialize it. + + The ``free`` argument is called when the object is garbage + collected, the default is ``grb_type.grb_type_free()``. If ``free`` is + None then there is no automatic garbage collection and it is up to + the user to free the type. + + >>> T = grb_type_new(8) + + """ + T = ffi.new("GrB_Type*") + check_status(T, lib.GrB_Type_new(T, sizeof_ctype)) + if free: + return ffi.gc(T, free) + return T + + +def grb_type_new_named(sizeof_ctype, type_name, type_defn, *, free=grb_type_free): + """Create a new named ``GrB_Type`` and initialize it. + + ``type_name`` and ``type_defn`` are strings describing the type. + + >>> T = grb_type_new_named(8, "my_type", "int64_t") + + """ + T = ffi.new("GrB_Type*") + check_status(T, lib.GxB_Type_new(T, sizeof_ctype, type_name.encode(), type_defn.encode())) + if free: + return ffi.gc(T, free) + return T + + +def grb_type_wait(T, waitmode=lib.GrB_COMPLETE): + """Wait for a type to complete pending operations. + + >>> T = grb_type_new(8) + >>> grb_type_wait(T) + + """ + check_status(T, lib.GrB_Type_wait(T[0], waitmode)) + + +def grb_type_print(T, name="", level=lib.GxB_COMPLETE): + """Print a type to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> out = _capture_c_output(grb_type_print, T, 'T', lib.GxB_SHORT) + >>> 'int64_t' in out + True + + """ + check_status( + T, + lib.GxB_Type_fprint( + T[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def grb_type_fprint(T, f, name="", level=lib.GxB_COMPLETE): + """Print a type to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`grb_type_print`). + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> out = _capture_c_output(grb_type_fprint, T, ffi.NULL, 'T', lib.GxB_SHORT) + >>> 'int64_t' in out + True + + """ + check_status( + T, + lib.GxB_Type_fprint( + T[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Get / Set +# --------------------------------------------------------------------------- + + +def grb_type_get_int32(T, field): + """Get a type property as an int32. + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> isinstance(grb_type_get_int32(T, lib.GrB_EL_TYPE_CODE), int) + True + + """ + val = ffi.new("int32_t*") + check_status(T, lib.GrB_Type_get_INT32(T[0], val, field)) + return val[0] + + +def grb_type_set_int32(T, field, value): + """Set a type property from an int32. + + >>> T = grb_type_new(8) + >>> grb_type_set_int32(T, lib.GrB_EL_TYPE_CODE, 11) + Traceback (most recent call last): + ... + suitesparse_graphblas.exceptions.InvalidValue + + """ + check_status(T, lib.GrB_Type_set_INT32(T[0], ffi.cast("int32_t", value), field)) + + +def grb_type_get_size(T, field): + """Get a type property as a size_t. + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> grb_type_get_size(T, lib.GrB_SIZE) + 8 + + """ + val = ffi.new("size_t*") + check_status(T, lib.GrB_Type_get_SIZE(T[0], val, field)) + return val[0] + + +def grb_type_get_string(T, field): + """Get a type property as a string. + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> grb_type_get_string(T, lib.GrB_NAME) + 'GrB_INT64' + + """ + val = ffi.new("char[256]") + check_status(T, lib.GrB_Type_get_String(T[0], val, field)) + return ffi.string(val).decode() + + +def grb_type_set_string(T, field, value): + """Set a type property from a string.""" + check_status(T, lib.GrB_Type_set_String(T[0], value.encode(), field)) + + +# --------------------------------------------------------------------------- +# Legacy GxB accessors +# --------------------------------------------------------------------------- + + +def grb_type_size(T): + """Return the size of the type in bytes. + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> grb_type_size(T) + 8 + + """ + sz = ffi.new("size_t*") + check_status(T, lib.GxB_Type_size(sz, T[0])) + return sz[0] + + +def grb_type_name(T): + """Return the name of the type. + + >>> T = ffi.new("GrB_Type*", lib.GrB_INT64) + >>> grb_type_name(T) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(T, lib.GxB_Type_name(name, T[0])) + return ffi.string(name).decode() + + +def grb_type_from_name(type_name): + """Look up a built-in type by name. + + >>> grb_type_from_name("GrB_INT64") == lib.GrB_INT64 + True + + """ + T = ffi.new("GrB_Type*") + check_status(T, lib.GxB_Type_from_name(T, type_name.encode())) + return T[0] diff --git a/suitesparse_graphblas/api/indexbinaryop.py b/suitesparse_graphblas/api/indexbinaryop.py new file mode 100644 index 0000000..4d513ae --- /dev/null +++ b/suitesparse_graphblas/api/indexbinaryop.py @@ -0,0 +1,135 @@ +"""GxB_IndexBinaryOp functional API. + +There are no built-in GxB_IndexBinaryOp constants in the library, so most +functions in this module cannot have doctests without constructing an operator +from a CFFI callback. Only ``indexbinaryop_new`` creates instances, and it +requires a C function pointer. +""" + +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def indexbinaryop_free(op): + """Free an index binary operator.""" + check_status(op, lib.GxB_IndexBinaryOp_free(op)) + + +def indexbinaryop_new( + function, ztype, xtype, ytype, theta_type, name, defn, *, free=indexbinaryop_free +): + """Create a new GxB_IndexBinaryOp from a C function pointer. + + ``function`` must be a CFFI callback compatible with + ``GxB_index_binary_function``. ``name`` and ``defn`` are C strings + describing the operator for JIT compilation. + + The ``free`` argument is called when the object is garbage + collected, the default is ``indexbinaryop.indexbinaryop_free()``. + If ``free`` is None then there is no automatic garbage collection + and it is up to the user to free the operator. + """ + op = ffi.new("GxB_IndexBinaryOp*") + check_status( + op, + lib.GxB_IndexBinaryOp_new( + op, + function, + ztype, + xtype, + ytype, + theta_type, + name.encode() if isinstance(name, str) else name, + defn.encode() if isinstance(defn, str) else defn, + ), + ) + if free: + return ffi.gc(op, free) + return op + + +def indexbinaryop_wait(op, waitmode=lib.GrB_COMPLETE): + """Wait for an index binary operator to complete pending operations.""" + check_status(op, lib.GxB_IndexBinaryOp_wait(op[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def indexbinaryop_print(op, name="", level=lib.GxB_COMPLETE): + """Print an index binary operator to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + """ + check_status( + op, + lib.GxB_IndexBinaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def indexbinaryop_fprint(op, f, name="", level=lib.GxB_COMPLETE): + """Print an index binary operator to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`indexbinaryop_print`). + """ + check_status( + op, + lib.GxB_IndexBinaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def indexbinaryop_get_int32(op, field): + """Get an operator option as an int32.""" + val = ffi.new("int32_t*") + check_status(op, lib.GxB_IndexBinaryOp_get_INT32(op[0], val, field)) + return val[0] + + +def indexbinaryop_set_int32(op, field, value): + """Set an operator option from an int32.""" + check_status(op, lib.GxB_IndexBinaryOp_set_INT32(op[0], ffi.cast("int32_t", value), field)) + + +def indexbinaryop_get_size(op, field): + """Get an operator option as a size_t.""" + val = ffi.new("size_t*") + check_status(op, lib.GxB_IndexBinaryOp_get_SIZE(op[0], val, field)) + return val[0] + + +def indexbinaryop_get_string(op, field): + """Get an operator option as a string.""" + val = ffi.new("char[256]") + check_status(op, lib.GxB_IndexBinaryOp_get_String(op[0], val, field)) + return ffi.string(val).decode() + + +def indexbinaryop_set_string(op, field, value): + """Set an operator option from a string.""" + check_status( + op, + lib.GxB_IndexBinaryOp_set_String( + op[0], value.encode() if isinstance(value, str) else value, field + ), + ) diff --git a/suitesparse_graphblas/api/indexunaryop.py b/suitesparse_graphblas/api/indexunaryop.py new file mode 100644 index 0000000..b333fc1 --- /dev/null +++ b/suitesparse_graphblas/api/indexunaryop.py @@ -0,0 +1,226 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def indexunaryop_free(op): + """Free an index unary operator. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_free(op) + + """ + check_status(op, lib.GrB_IndexUnaryOp_free(op)) + + +def indexunaryop_new(function, ztype, xtype, ytype, *, free=indexunaryop_free): + """Create a new GrB_IndexUnaryOp from a C function pointer. + + ``function`` must be a CFFI callback compatible with + ``GxB_index_unary_function``. + + The ``free`` argument is called when the object is garbage + collected, the default is ``indexunaryop.indexunaryop_free()``. If + ``free`` is None then there is no automatic garbage collection and + it is up to the user to free the operator. + """ + op = ffi.new("GrB_IndexUnaryOp*") + check_status(op, lib.GrB_IndexUnaryOp_new(op, function, ztype, xtype, ytype)) + if free: + return ffi.gc(op, free) + return op + + +def indexunaryop_new_named(function, ztype, xtype, ytype, name, defn, *, free=indexunaryop_free): + """Create a new named GrB_IndexUnaryOp (GxB extension). + + ``function`` must be a CFFI callback compatible with + ``GxB_index_unary_function``. ``name`` and ``defn`` are C strings + describing the operator for JIT compilation. + + The ``free`` argument is called when the object is garbage + collected, the default is ``indexunaryop.indexunaryop_free()``. If + ``free`` is None then there is no automatic garbage collection and + it is up to the user to free the operator. + """ + op = ffi.new("GrB_IndexUnaryOp*") + check_status( + op, + lib.GxB_IndexUnaryOp_new( + op, + function, + ztype, + xtype, + ytype, + name.encode() if isinstance(name, str) else name, + defn.encode() if isinstance(defn, str) else defn, + ), + ) + if free: + return ffi.gc(op, free) + return op + + +def indexunaryop_wait(op, waitmode=lib.GrB_COMPLETE): + """Wait for an index unary operator to complete pending operations. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_wait(op) + + """ + check_status(op, lib.GrB_IndexUnaryOp_wait(op[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def indexunaryop_print(op, name="", level=lib.GxB_COMPLETE): + """Print an index unary operator to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> out = _capture_c_output(indexunaryop_print, op, 'op', lib.GxB_SHORT) + >>> 'rowindex' in out.lower() + True + + """ + check_status( + op, + lib.GxB_IndexUnaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def indexunaryop_fprint(op, f, name="", level=lib.GxB_COMPLETE): + """Print an index unary operator to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`indexunaryop_print`). + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> out = _capture_c_output(indexunaryop_fprint, op, ffi.NULL, 'op', lib.GxB_SHORT) + >>> 'rowindex' in out.lower() + True + + """ + check_status( + op, + lib.GxB_IndexUnaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def indexunaryop_get_int32(op, field): + """Get an operator option as an int32. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_get_int32(op, lib.GrB_OUTP_TYPE_CODE) >= 0 + True + + """ + val = ffi.new("int32_t*") + check_status(op, lib.GrB_IndexUnaryOp_get_INT32(op[0], val, field)) + return val[0] + + +def indexunaryop_set_int32(op, field, value): + """Set an operator option from an int32.""" + check_status(op, lib.GrB_IndexUnaryOp_set_INT32(op[0], ffi.cast("int32_t", value), field)) + + +def indexunaryop_get_size(op, field): + """Get an operator option as a size_t. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_get_size(op, lib.GrB_NAME) > 0 + True + + """ + val = ffi.new("size_t*") + check_status(op, lib.GrB_IndexUnaryOp_get_SIZE(op[0], val, field)) + return val[0] + + +def indexunaryop_get_string(op, field): + """Get an operator option as a string. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> 'rowindex' in indexunaryop_get_string(op, lib.GrB_NAME).lower() + True + + """ + val = ffi.new("char[256]") + check_status(op, lib.GrB_IndexUnaryOp_get_String(op[0], val, field)) + return ffi.string(val).decode() + + +def indexunaryop_set_string(op, field, value): + """Set an operator option from a string.""" + check_status( + op, + lib.GrB_IndexUnaryOp_set_String( + op[0], value.encode() if isinstance(value, str) else value, field + ), + ) + + +# --------------------------------------------------------------------------- +# Type name queries +# --------------------------------------------------------------------------- + + +def indexunaryop_xtype_name(op): + """Return the input (x) type name of an index unary operator as a string. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_xtype_name(op) + '' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_IndexUnaryOp_xtype_name(name, op[0])) + return ffi.string(name).decode() + + +def indexunaryop_ytype_name(op): + """Return the thunk (y) type name of an index unary operator as a string. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_ytype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_IndexUnaryOp_ytype_name(name, op[0])) + return ffi.string(name).decode() + + +def indexunaryop_ztype_name(op): + """Return the output (z) type name of an index unary operator as a string. + + >>> op = ffi.new("GrB_IndexUnaryOp*", lib.GrB_ROWINDEX_INT64) + >>> indexunaryop_ztype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_IndexUnaryOp_ztype_name(name, op[0])) + return ffi.string(name).decode() diff --git a/suitesparse_graphblas/api/io/__init__.py b/suitesparse_graphblas/api/io/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/suitesparse_graphblas/api/io/binary.py b/suitesparse_graphblas/api/io/binary.py new file mode 100644 index 0000000..974ecf0 --- /dev/null +++ b/suitesparse_graphblas/api/io/binary.py @@ -0,0 +1,480 @@ +from contextlib import ExitStack +from pathlib import Path + +import numpy as np + +from suitesparse_graphblas import __version__, check_status, ffi, lib +from suitesparse_graphblas.api import matrix +from suitesparse_graphblas.utils import empty, give_buffer + +GRB_HEADER_LEN = 512 +NULL = ffi.NULL + +header_template = """\ +SuiteSparse:GraphBLAS matrix +{suitesparse_version} ({user_agent}) +nrows: {nrows} +ncols: {ncols} +nvec: {nvec} +nvals: {nvals} +format: {format} +size: {size} +type: {type} +iso: {iso} +{comments} +""" + +sizeof = ffi.sizeof +ffinew = ffi.new +buff = ffi.buffer +frombuff = ffi.from_buffer +Isize = ffi.sizeof("GrB_Index") + +_ss_typecodes = { + lib.GrB_BOOL: 0, + lib.GrB_INT8: 1, + lib.GrB_INT16: 2, + lib.GrB_INT32: 3, + lib.GrB_INT64: 4, + lib.GrB_UINT8: 5, + lib.GrB_UINT16: 6, + lib.GrB_UINT32: 7, + lib.GrB_UINT64: 8, + lib.GrB_FP32: 9, + lib.GrB_FP64: 10, + lib.GxB_FC32: 11, + lib.GxB_FC64: 12, +} + +_ss_typenames = { + lib.GrB_BOOL: "GrB_BOOL", + lib.GrB_INT8: "GrB_INT8", + lib.GrB_INT16: "GrB_INT16", + lib.GrB_INT32: "GrB_INT32", + lib.GrB_INT64: "GrB_INT64", + lib.GrB_UINT8: "GrB_UINT8", + lib.GrB_UINT16: "GrB_UINT16", + lib.GrB_UINT32: "GrB_UINT32", + lib.GrB_UINT64: "GrB_UINT64", + lib.GrB_FP32: "GrB_FP32", + lib.GrB_FP64: "GrB_FP64", + lib.GxB_FC32: "GxB_FC32", + lib.GxB_FC64: "GxB_FC64", +} + +_ss_codetypes = {v: k for k, v in _ss_typecodes.items()} + + +def binwrite(A, filename, comments=None, opener=Path.open): + """Write Matrix ``A`` to ``filename`` in SuiteSparse:GraphBLAS's binary format. + + ``opener`` opens the file for writing (e.g. ``gzip.open`` to compress it). To avoid a + copy, ``A`` is unpacked while it is written and packed again afterwards (even if writing + fails), so other threads must not use ``A`` meanwhile. + """ + if isinstance(filename, str): + filename = Path(filename) + + check_status(A, lib.GrB_Matrix_wait(A[0], lib.GrB_MATERIALIZE)) + + ffinew = ffi.new + + Ap = ffinew("GrB_Index**") + Ai = ffinew("GrB_Index**") + Ah = ffinew("GrB_Index**") + Ax = ffinew("void**") + Ab = ffinew("int8_t**") + + Ap_size = ffinew("GrB_Index*") + Ai_size = ffinew("GrB_Index*") + Ah_size = ffinew("GrB_Index*") + Ax_size = ffinew("GrB_Index*") + Ab_size = ffinew("GrB_Index*") + + nvec = ffinew("GrB_Index*") + nrows = ffinew("GrB_Index*") + ncols = ffinew("GrB_Index*") + nvals = ffinew("GrB_Index*") + + typesize = ffi.new("size_t*") + is_iso = ffinew("bool*") + is_jumbled = ffinew("bool*") + + impl = ffi.new("uint64_t*", lib.GxB_IMPLEMENTATION) + format = ffinew("GxB_Format_Value*") + hyper_switch = ffinew("double*") + bitmap_switch = ffinew("double*") + sparsity_control = ffinew("int32_t*") + sparsity_status = ffinew("int32_t*") + + typecode = ffinew("int32_t*") + matrix_type = ffi.new("GrB_Type*") + + nrows[0] = matrix.matrix_nrows(A) + ncols[0] = matrix.matrix_ncols(A) + nvals[0] = matrix.matrix_nvals(A) + matrix_type[0] = matrix.matrix_type(A) + + check_status(A, lib.GxB_Type_size(typesize, matrix_type[0])) + typecode[0] = _ss_typecodes[matrix_type[0]] + + format[0] = matrix.matrix_format(A) + hyper_switch[0] = matrix.matrix_hyper_switch(A) + bitmap_switch[0] = matrix.matrix_bitmap_switch(A) + sparsity_status[0] = matrix.matrix_sparsity_status(A) + sparsity_control[0] = matrix.matrix_sparsity_control(A) + + by_row = format[0] == lib.GxB_BY_ROW + by_col = format[0] == lib.GxB_BY_COL + + is_hyper = sparsity_status[0] == lib.GxB_HYPERSPARSE + is_sparse = sparsity_status[0] == lib.GxB_SPARSE + is_bitmap = sparsity_status[0] == lib.GxB_BITMAP + is_full = sparsity_status[0] == lib.GxB_FULL + + if by_col and is_hyper: + check_status( + A, + lib.GxB_Matrix_unpack_HyperCSC( + A[0], + Ap, + Ah, + Ai, + Ax, + Ap_size, + Ah_size, + Ai_size, + Ax_size, + is_iso, + nvec, + is_jumbled, + NULL, + ), + ) + fmt_string = "HCSC" + + elif by_row and is_hyper: + check_status( + A, + lib.GxB_Matrix_unpack_HyperCSR( + A[0], + Ap, + Ah, + Ai, + Ax, + Ap_size, + Ah_size, + Ai_size, + Ax_size, + is_iso, + nvec, + is_jumbled, + NULL, + ), + ) + fmt_string = "HCSR" + + elif by_col and is_sparse: + check_status( + A, + lib.GxB_Matrix_unpack_CSC( + A[0], Ap, Ai, Ax, Ap_size, Ai_size, Ax_size, is_iso, is_jumbled, NULL + ), + ) + nvec[0] = ncols[0] + fmt_string = "CSC" + + elif by_row and is_sparse: + check_status( + A, + lib.GxB_Matrix_unpack_CSR( + A[0], Ap, Ai, Ax, Ap_size, Ai_size, Ax_size, is_iso, is_jumbled, NULL + ), + ) + nvec[0] = nrows[0] + fmt_string = "CSR" + + elif by_col and is_bitmap: + check_status( + A, lib.GxB_Matrix_unpack_BitmapC(A[0], Ab, Ax, Ab_size, Ax_size, is_iso, nvals, NULL) + ) + nvec[0] = ncols[0] + fmt_string = "BITMAPC" + + elif by_row and is_bitmap: + check_status( + A, lib.GxB_Matrix_unpack_BitmapR(A[0], Ab, Ax, Ab_size, Ax_size, is_iso, nvals, NULL) + ) + nvec[0] = nrows[0] + fmt_string = "BITMAPR" + + elif by_col and is_full: + check_status(A, lib.GxB_Matrix_unpack_FullC(A[0], Ax, Ax_size, is_iso, NULL)) + nvec[0] = ncols[0] + fmt_string = "FULLC" + + elif by_row and is_full: + check_status(A, lib.GxB_Matrix_unpack_FullR(A[0], Ax, Ax_size, is_iso, NULL)) + nvec[0] = nrows[0] + fmt_string = "FULLR" + + else: # pragma nocover + raise TypeError(f"Unknown Matrix format {format[0]}") + + suitesparse_version = ( + f"v{lib.GxB_IMPLEMENTATION_MAJOR}." + f"{lib.GxB_IMPLEMENTATION_MINOR}." + f"{lib.GxB_IMPLEMENTATION_SUB}" + ) + + vars = dict( # noqa: C408 + suitesparse_version=suitesparse_version, + user_agent="pygraphblas-" + __version__, + nrows=nrows[0], + ncols=ncols[0], + nvals=nvals[0], + nvec=nvec[0], + format=fmt_string, + size=typesize[0], + type=_ss_typenames[matrix_type[0]], + iso=int(is_iso[0]), + comments=comments, + ) + header_content = header_template.format(**vars) + header = f"{header_content: <{GRB_HEADER_LEN}}".encode("ascii") + + try: + with opener(filename, "wb") as f: + fwrite = f.write + fwrite(header) + fwrite(buff(impl, sizeof("uint64_t"))) + fwrite(buff(format, sizeof("GxB_Format_Value"))) + fwrite(buff(sparsity_status, sizeof("int32_t"))) + fwrite(buff(sparsity_control, sizeof("int32_t"))) + fwrite(buff(hyper_switch, sizeof("double"))) + fwrite(buff(bitmap_switch, sizeof("double"))) + fwrite(buff(nrows, Isize)) + fwrite(buff(ncols, Isize)) + fwrite(buff(nvec, Isize)) + fwrite(buff(nvals, Isize)) + fwrite(buff(typecode, sizeof("int32_t"))) + fwrite(buff(typesize, sizeof("size_t"))) + fwrite(buff(is_iso, sizeof("bool"))) + + Tsize = typesize[0] + iso = is_iso[0] + + if is_hyper: + fwrite(buff(Ap[0], (nvec[0] + 1) * Isize)) + fwrite(buff(Ah[0], nvec[0] * Isize)) + fwrite(buff(Ai[0], nvals[0] * Isize)) + Axsize = Tsize if iso else nvals[0] * Tsize + elif is_sparse: + fwrite(buff(Ap[0], (nvec[0] + 1) * Isize)) + fwrite(buff(Ai[0], nvals[0] * Isize)) + Axsize = Tsize if iso else nvals[0] * Tsize + elif is_bitmap: + fwrite(buff(Ab[0], nrows[0] * ncols[0] * ffi.sizeof("int8_t"))) + Axsize = Tsize if iso else nrows[0] * ncols[0] * Tsize + else: + Axsize = Tsize if iso else nrows[0] * ncols[0] * Tsize + + fwrite(buff(Ax[0], Axsize)) + finally: + # The matrix was unpacked to write its arrays, so give them back even if that failed + if by_col and is_hyper: + check_status( + A, + lib.GxB_Matrix_pack_HyperCSC( + A[0], + Ap, + Ah, + Ai, + Ax, + Ap_size[0], + Ah_size[0], + Ai_size[0], + Ax_size[0], + is_iso[0], + nvec[0], + is_jumbled[0], + NULL, + ), + ) + + elif by_row and is_hyper: + check_status( + A, + lib.GxB_Matrix_pack_HyperCSR( + A[0], + Ap, + Ah, + Ai, + Ax, + Ap_size[0], + Ah_size[0], + Ai_size[0], + Ax_size[0], + is_iso[0], + nvec[0], + is_jumbled[0], + NULL, + ), + ) + + elif by_col and is_sparse: + check_status( + A, + lib.GxB_Matrix_pack_CSC( + A[0], + Ap, + Ai, + Ax, + Ap_size[0], + Ai_size[0], + Ax_size[0], + is_iso[0], + is_jumbled[0], + NULL, + ), + ) + + elif by_row and is_sparse: + check_status( + A, + lib.GxB_Matrix_pack_CSR( + A[0], + Ap, + Ai, + Ax, + Ap_size[0], + Ai_size[0], + Ax_size[0], + is_iso[0], + is_jumbled[0], + NULL, + ), + ) + + elif by_col and is_bitmap: + check_status( + A, + lib.GxB_Matrix_pack_BitmapC( + A[0], Ab, Ax, Ab_size[0], Ax_size[0], is_iso[0], nvals[0], NULL + ), + ) + + elif by_row and is_bitmap: + check_status( + A, + lib.GxB_Matrix_pack_BitmapR( + A[0], Ab, Ax, Ab_size[0], Ax_size[0], is_iso[0], nvals[0], NULL + ), + ) + + elif by_col and is_full: + check_status(A, lib.GxB_Matrix_pack_FullC(A[0], Ax, Ax_size[0], is_iso[0], NULL)) + + elif by_row and is_full: + check_status(A, lib.GxB_Matrix_pack_FullR(A[0], Ax, Ax_size[0], is_iso[0], NULL)) + else: + raise TypeError("This should never happen") + + +def binread(filename, opener=Path.open): + """Read a Matrix from ``filename``, written by ``binwrite``. + + ``opener`` opens the file for reading (e.g. ``gzip.open``). + """ + if isinstance(filename, str): + filename = Path(filename) + + with opener(filename, "rb") as f: + fread = f.read + + fread(GRB_HEADER_LEN) + impl = frombuff("uint64_t*", fread(sizeof("uint64_t"))) + + assert impl[0] == lib.GxB_IMPLEMENTATION + + format = frombuff("GxB_Format_Value*", fread(sizeof("GxB_Format_Value"))) + sparsity_status = frombuff("int32_t*", fread(sizeof("int32_t"))) + sparsity_control = frombuff("int32_t*", fread(sizeof("int32_t"))) + hyper_switch = frombuff("double*", fread(sizeof("double"))) + bitmap_switch = frombuff("double*", fread(sizeof("double"))) + nrows = frombuff("GrB_Index*", fread(Isize)) + ncols = frombuff("GrB_Index*", fread(Isize)) + nvec = frombuff("GrB_Index*", fread(Isize)) + nvals = frombuff("GrB_Index*", fread(Isize)) + typecode = frombuff("int32_t*", fread(sizeof("int32_t"))) + typesize = frombuff("size_t*", fread(sizeof("size_t"))) + is_iso = frombuff("bool*", fread(sizeof("bool"))) + + by_row = format[0] == lib.GxB_BY_ROW + by_col = format[0] == lib.GxB_BY_COL + + is_hyper = sparsity_status[0] == lib.GxB_HYPERSPARSE + is_sparse = sparsity_status[0] == lib.GxB_SPARSE + is_bitmap = sparsity_status[0] == lib.GxB_BITMAP + is_full = sparsity_status[0] == lib.GxB_FULL + + atype = _ss_codetypes[typecode[0]] + + if not (by_row or by_col): + raise TypeError(f"Unknown format {format[0]}") + + A = matrix.matrix_new(atype, nrows[0], ncols[0]) + # GraphBLAS will own the buffers we read into, and takes them to be from the data + # arena that new matrices use + arena = ffinew("int32_t*") + check_status(A, lib.GrB_Matrix_get_INT32(A[0], arena, lib.GxB_ARENA_DATA)) + arena = arena[0] + buffers = [] # (array, ctype), in the order the file and `GxB_Matrix_pack_*` have them + + def read(nbytes, ctype): + array = empty(nbytes, np.uint8, arena=arena) + if f.readinto(array) != nbytes: + raise EOFError(f"{filename} is truncated") + buffers.append((array, ctype)) + + if is_hyper: + pack = lib.GxB_Matrix_pack_HyperCSC if by_col else lib.GxB_Matrix_pack_HyperCSR + read((nvec[0] + 1) * Isize, "GrB_Index*") # Ap + read(nvec[0] * Isize, "GrB_Index*") # Ah + read(nvals[0] * Isize, "GrB_Index*") # Ai + nx = nvals[0] + args = [nvec[0], False] # False: not jumbled + elif is_sparse: + pack = lib.GxB_Matrix_pack_CSC if by_col else lib.GxB_Matrix_pack_CSR + read((nvec[0] + 1) * Isize, "GrB_Index*") # Ap + read(nvals[0] * Isize, "GrB_Index*") # Ai + nx = nvals[0] + args = [False] # not jumbled + elif is_bitmap: + pack = lib.GxB_Matrix_pack_BitmapC if by_col else lib.GxB_Matrix_pack_BitmapR + read(nrows[0] * ncols[0], "int8_t*") # Ab + nx = nrows[0] * ncols[0] + args = [nvals[0]] + elif is_full: + pack = lib.GxB_Matrix_pack_FullC if by_col else lib.GxB_Matrix_pack_FullR + nx = nrows[0] * ncols[0] + args = [] + else: + raise TypeError(f"Unknown sparsity status {sparsity_status[0]}") + # An iso matrix stores a single value, and GraphBLAS must be told its true size + read(typesize[0] if is_iso[0] else nx * typesize[0], "void*") # Ax + + with ExitStack() as stack: + # The buffers become GraphBLAS's only if the pack succeeds + given = [ + stack.enter_context(give_buffer(array, ctype, copy=False, arena=arena)) + for array, ctype in buffers + ] + ptrs = [ptr for ptr, _, _ in given] + sizes = [nbytes for _, nbytes, _ in given] + check_status(A, pack(A[0], *ptrs, *sizes, is_iso[0], *args, NULL)) + + matrix.matrix_set_sparsity_control(A, sparsity_control[0]) + matrix.matrix_set_hyper_switch(A, hyper_switch[0]) + matrix.matrix_set_bitmap_switch(A, bitmap_switch[0]) + return A diff --git a/suitesparse_graphblas/api/io/serialize.py b/suitesparse_graphblas/api/io/serialize.py new file mode 100644 index 0000000..c6aefde --- /dev/null +++ b/suitesparse_graphblas/api/io/serialize.py @@ -0,0 +1,147 @@ +import numpy as np + +from suitesparse_graphblas import check_status, ffi, lib +from suitesparse_graphblas.api.global_options import global_get_int32 +from suitesparse_graphblas.utils import claim_buffer + + +def _free_desc(desc): + """Free a descriptor via a temporary pointer.""" + desc_ptr = ffi.new("GrB_Descriptor*", desc) + lib.GrB_Descriptor_free(desc_ptr) + + +def get_serialize_desc(compression=lib.GxB_COMPRESSION_DEFAULT, level=None, nthreads=None): + """Create a descriptor for serializing or deserializing. + + This returns None (for NULL descriptor) or a GrB_Descriptor. + """ + if nthreads is None and (compression is None or compression == lib.GxB_COMPRESSION_DEFAULT): + return None + desc_ptr = ffi.new("GrB_Descriptor*") + check_status(desc_ptr, lib.GrB_Descriptor_new(desc_ptr)) + desc = ffi.gc(desc_ptr[0], _free_desc) + if nthreads is not None: + check_status( + desc, + lib.GxB_Desc_set_INT32(desc, lib.GxB_NTHREADS, ffi.cast("int32_t", nthreads)), + ) + if compression is not None: + if level is not None and compression in { + lib.GxB_COMPRESSION_LZ4HC, + lib.GxB_COMPRESSION_ZSTD, + }: + compression += level + check_status( + desc, + lib.GxB_Desc_set_INT32(desc, lib.GxB_COMPRESSION, ffi.cast("int32_t", compression)), + ) + return desc + + +def serialize_matrix(A, compression=lib.GxB_COMPRESSION_DEFAULT, level=None, *, nthreads=None): + """Serialize a Matrix into an array of bytes. + + Parameters + ---------- + compression : int, optional + One of None, GxB_COMPRESSION_NONE, GxB_COMPRESSION_DEFAULT, + GxB_COMPRESSION_LZ4, GxB_COMPRESSION_LZ4HC, or GxB_COMPRESSION_ZSTD + level : int, optional + For GxB_COMPRESSION_LZ4HC, should be between 1 and 9, where 9 is most compressed. + For GxB_COMPRESSION_ZSTD, should be between 1 and 19, where 19 is most compressed. + + nthreads : int, optional + The maximum number of OpenMP threads to use. + """ + desc = get_serialize_desc(compression, level, nthreads) + data_ptr = ffi.new("void**") + size_ptr = ffi.new("GrB_Index*") + # Name the arena for the result, which is otherwise that of the engaged Context (if + # any), so that `claim_buffer` knows which allocator must free it + arena = global_get_int32(lib.GxB_ARENA_DATA) + desc = ffi.NULL if desc is None else desc + check_status(A, lib.GxB_Matrix_serialize_arena(data_ptr, size_ptr, A[0], arena, desc)) + return claim_buffer(ffi, data_ptr[0], size_ptr[0], np.dtype(np.uint8), arena) + + +def serialize_vector(v, compression=lib.GxB_COMPRESSION_DEFAULT, level=None, *, nthreads=None): + """Serialize a Vector into an array of bytes. + + Parameters + ---------- + compression : int, optional + One of None, GxB_COMPRESSION_NONE, GxB_COMPRESSION_DEFAULT, + GxB_COMPRESSION_LZ4, GxB_COMPRESSION_LZ4HC, or GxB_COMPRESSION_ZSTD + level : int, optional + For GxB_COMPRESSION_LZ4HC, should be between 1 and 9, where 9 is most compressed. + For GxB_COMPRESSION_ZSTD, should be between 1 and 19, where 19 is most compressed. + nthreads : int, optional + The maximum number of OpenMP threads to use. + """ + desc = get_serialize_desc(compression, level, nthreads) + data_ptr = ffi.new("void**") + size_ptr = ffi.new("GrB_Index*") + arena = global_get_int32(lib.GxB_ARENA_DATA) # see `serialize_matrix` + desc = ffi.NULL if desc is None else desc + check_status(v, lib.GxB_Vector_serialize_arena(data_ptr, size_ptr, v[0], arena, desc)) + return claim_buffer(ffi, data_ptr[0], size_ptr[0], np.dtype(np.uint8), arena) + + +def deserialize_matrix(data, *, free=True, nthreads=None): + """Deserialize a Matrix from bytes. + + The `free` argument is called when the object is garbage + collected, the default is `matrix.matrix_free()`. If `free` is None then + there is no automatic garbage collection and it is up to the user + to free the matrix. + """ + data = np.frombuffer(data, np.uint8) + desc = get_serialize_desc(None, nthreads) + A = ffi.new("GrB_Matrix*") + check_status( + A, + lib.GxB_Matrix_deserialize( + A, + ffi.NULL, # dtype; we don't check for now + ffi.from_buffer("void*", data), + data.nbytes, + ffi.NULL if desc is None else desc, + ), + ) + if free: + if callable(free): + return ffi.gc(A, free) + return ffi.gc(A, matrix.matrix_free) + return A + + +def deserialize_vector(data, *, free=True, nthreads=None): + """Deserialize a Vector from bytes. + + The `free` argument is called when the object is garbage + collected, the default is `vector.vector_free()`. If `free` is None then + there is no automatic garbage collection and it is up to the user + to free the vector. + """ + data = np.frombuffer(data, np.uint8) + desc = get_serialize_desc(None, nthreads) + v = ffi.new("GrB_Vector*") + check_status( + v, + lib.GxB_Vector_deserialize( + v, + ffi.NULL, # dtype; we don't check for now + ffi.from_buffer("void*", data), + data.nbytes, + ffi.NULL if desc is None else desc, + ), + ) + if free: + if callable(free): + return ffi.gc(v, free) + return ffi.gc(v, vector.vector_free) + return v + + +from suitesparse_graphblas.api import matrix, vector # noqa: E402 isort:skip diff --git a/suitesparse_graphblas/api/iterator.py b/suitesparse_graphblas/api/iterator.py new file mode 100644 index 0000000..bf47f1a --- /dev/null +++ b/suitesparse_graphblas/api/iterator.py @@ -0,0 +1,571 @@ +from suitesparse_graphblas import _error_code_lookup, check_status, ffi, lib, supports_complex + + +def _check_info(info): + """Check a GrB_Info code, returning it on SUCCESS/EXHAUSTED/NO_VALUE, raising otherwise.""" + if info == lib.GrB_SUCCESS or info == lib.GxB_EXHAUSTED or info == lib.GrB_NO_VALUE: + return info + exc_class = _error_code_lookup.get(info, RuntimeError) + raise exc_class(f"GraphBLAS error: info={info}") + + +# --------------------------------------------------------------------------- +# Iterator lifecycle +# --------------------------------------------------------------------------- + + +def iterator_free(it): + """Free an iterator.""" + check_status(it, lib.GxB_Iterator_free(it)) + + +def iterator_new(*, free=iterator_free): + """Create a new GxB_Iterator. + + >>> it = iterator_new() + + """ + it = ffi.new("GxB_Iterator*") + check_status(it, lib.GxB_Iterator_new(it)) + if free: + return ffi.gc(it, free) + return it + + +# --------------------------------------------------------------------------- +# Attach +# --------------------------------------------------------------------------- + + +def matrix_iterator_attach(it, A, desc=None): + """Attach an iterator to a matrix for entry-wise iteration. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED`` (if the matrix + has no entries). Raises on other errors. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> info = matrix_iterator_attach(it, A) + >>> info == lib.GrB_SUCCESS + True + + """ + info = lib.GxB_Matrix_Iterator_attach( + it[0], + A[0], + ffi.NULL if desc is None else desc, + ) + return _check_info(info) + + +def row_iterator_attach(it, A, desc=None): + """Attach an iterator to a matrix for row-wise iteration. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> info = row_iterator_attach(it, A) + >>> info == lib.GrB_SUCCESS + True + + """ + info = lib.GxB_rowIterator_attach( + it[0], + A[0], + ffi.NULL if desc is None else desc, + ) + return _check_info(info) + + +def col_iterator_attach(it, A, desc=None): + """Attach an iterator to a matrix for column-wise iteration. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_set_format(A, lib.GxB_BY_COL) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> info = col_iterator_attach(it, A) + >>> info == lib.GrB_SUCCESS + True + + """ + info = lib.GxB_colIterator_attach( + it[0], + A[0], + ffi.NULL if desc is None else desc, + ) + return _check_info(info) + + +def vector_iterator_attach(it, v, desc=None): + """Attach an iterator to a vector. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import vector + >>> v = vector.vector_new(lib.GrB_INT64, 3) + >>> vector.set_int64(v, 42, 0) + >>> vector.set_int64(v, 7, 2) + >>> vector.vector_wait(v, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> info = vector_iterator_attach(it, v) + >>> info == lib.GrB_SUCCESS + True + + """ + info = lib.GxB_Vector_Iterator_attach( + it[0], + v[0], + ffi.NULL if desc is None else desc, + ) + return _check_info(info) + + +# --------------------------------------------------------------------------- +# Matrix entry iterator +# --------------------------------------------------------------------------- + + +def matrix_iterator_seek(it, p): + """Seek the matrix entry iterator to position p. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> matrix_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> matrix_iterator_seek(it, 0) == lib.GrB_SUCCESS + True + + """ + info = lib.GxB_Matrix_Iterator_seek(it[0], p) + return _check_info(info) + + +def matrix_iterator_next(it): + """Advance the matrix entry iterator to the next entry. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> matrix_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> matrix_iterator_seek(it, 0) == lib.GrB_SUCCESS + True + >>> iterator_get_int64(it) + 10 + >>> matrix_iterator_next(it) == lib.GrB_SUCCESS + True + >>> iterator_get_int64(it) + 20 + >>> matrix_iterator_next(it) == lib.GxB_EXHAUSTED + True + + """ + info = lib.GxB_Matrix_Iterator_next(it[0]) + return _check_info(info) + + +def matrix_iterator_get_index(it): + """Get the row and column index of the current matrix entry. + + Returns a ``(row, col)`` tuple. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> matrix_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> matrix_iterator_seek(it, 0) == lib.GrB_SUCCESS + True + >>> matrix_iterator_get_index(it) + (0, 1) + + """ + row = ffi.new("GrB_Index*") + col = ffi.new("GrB_Index*") + lib.GxB_Matrix_Iterator_getIndex(it[0], row, col) + return (row[0], col[0]) + + +def matrix_iterator_getp(it): + """Get the current position of the matrix entry iterator.""" + return lib.GxB_Matrix_Iterator_getp(it[0]) + + +def matrix_iterator_getpmax(it): + """Get the maximum position of the matrix entry iterator.""" + return lib.GxB_Matrix_Iterator_getpmax(it[0]) + + +# --------------------------------------------------------------------------- +# Row iterator +# --------------------------------------------------------------------------- + + +def row_iterator_seek_row(it, row): + """Seek the row iterator to a specific row. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> row_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> row_iterator_seek_row(it, 1) == lib.GrB_SUCCESS + True + >>> iterator_get_int64(it) + 20 + + """ + info = lib.GxB_rowIterator_seekRow(it[0], row) + return _check_info(info) + + +def row_iterator_next_row(it): + """Advance the row iterator to the next non-empty row. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> row_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> row_iterator_get_row_index(it) + 0 + >>> row_iterator_next_row(it) == lib.GrB_SUCCESS + True + >>> row_iterator_get_row_index(it) + 1 + + """ + info = lib.GxB_rowIterator_nextRow(it[0]) + return _check_info(info) + + +def row_iterator_next_col(it): + """Advance the row iterator to the next entry in the current row. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 0, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> row_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> iterator_get_int64(it) + 10 + >>> _ = row_iterator_next_col(it) + >>> iterator_get_int64(it) + 20 + >>> row_iterator_get_col_index(it) + 1 + + """ + info = lib.GxB_rowIterator_nextCol(it[0]) + return _check_info(info) + + +def row_iterator_kseek(it, k): + """Seek the row iterator to the k-th entry in the current row. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + """ + info = lib.GxB_rowIterator_kseek(it[0], k) + return _check_info(info) + + +def row_iterator_get_row_index(it): + """Get the current row index of the row iterator.""" + return lib.GxB_rowIterator_getRowIndex(it[0]) + + +def row_iterator_get_col_index(it): + """Get the current column index of the row iterator.""" + return lib.GxB_rowIterator_getColIndex(it[0]) + + +def row_iterator_kount(it): + """Get the number of entries in the current row.""" + return lib.GxB_rowIterator_kount(it[0]) + + +# --------------------------------------------------------------------------- +# Column iterator +# --------------------------------------------------------------------------- + + +def col_iterator_seek_col(it, col): + """Seek the column iterator to a specific column. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_set_format(A, lib.GxB_BY_COL) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> col_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> col_iterator_seek_col(it, 1) == lib.GrB_SUCCESS + True + >>> iterator_get_int64(it) + 20 + + """ + info = lib.GxB_colIterator_seekCol(it[0], col) + return _check_info(info) + + +def col_iterator_next_col(it): + """Advance the column iterator to the next non-empty column. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix.matrix_set_format(A, lib.GxB_BY_COL) + >>> matrix.matrix_option_set_int32(A, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.matrix_wait(A, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> col_iterator_attach(it, A) == lib.GrB_SUCCESS + True + >>> col_iterator_get_col_index(it) + 0 + >>> col_iterator_next_col(it) == lib.GrB_SUCCESS + True + >>> col_iterator_get_col_index(it) + 1 + + """ + info = lib.GxB_colIterator_nextCol(it[0]) + return _check_info(info) + + +def col_iterator_next_row(it): + """Advance the column iterator to the next entry in the current column. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + """ + info = lib.GxB_colIterator_nextRow(it[0]) + return _check_info(info) + + +def col_iterator_kseek(it, k): + """Seek the column iterator to the k-th entry in the current column. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + """ + info = lib.GxB_colIterator_kseek(it[0], k) + return _check_info(info) + + +def col_iterator_get_col_index(it): + """Get the current column index of the column iterator.""" + return lib.GxB_colIterator_getColIndex(it[0]) + + +def col_iterator_get_row_index(it): + """Get the current row index of the column iterator.""" + return lib.GxB_colIterator_getRowIndex(it[0]) + + +def col_iterator_kount(it): + """Get the number of entries in the current column.""" + return lib.GxB_colIterator_kount(it[0]) + + +# --------------------------------------------------------------------------- +# Vector iterator +# --------------------------------------------------------------------------- + + +def vector_iterator_seek(it, p): + """Seek the vector iterator to position p. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import vector + >>> v = vector.vector_new(lib.GrB_INT64, 3) + >>> vector.set_int64(v, 42, 0) + >>> vector.set_int64(v, 7, 2) + >>> vector.vector_wait(v, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> vector_iterator_attach(it, v) == lib.GrB_SUCCESS + True + >>> vector_iterator_seek(it, 0) == lib.GrB_SUCCESS + True + >>> iterator_get_int64(it) + 42 + + """ + info = lib.GxB_Vector_Iterator_seek(it[0], p) + return _check_info(info) + + +def vector_iterator_next(it): + """Advance the vector iterator to the next entry. + + Returns ``lib.GrB_SUCCESS`` or ``lib.GxB_EXHAUSTED``. + + >>> from suitesparse_graphblas import vector + >>> v = vector.vector_new(lib.GrB_INT64, 3) + >>> vector.set_int64(v, 42, 0) + >>> vector.set_int64(v, 7, 2) + >>> vector.vector_wait(v, lib.GrB_MATERIALIZE) + >>> it = iterator_new() + >>> vector_iterator_attach(it, v) == lib.GrB_SUCCESS + True + >>> vector_iterator_seek(it, 0) == lib.GrB_SUCCESS + True + >>> vector_iterator_get_index(it) + 0 + >>> iterator_get_int64(it) + 42 + >>> vector_iterator_next(it) == lib.GrB_SUCCESS + True + >>> vector_iterator_get_index(it) + 2 + >>> iterator_get_int64(it) + 7 + >>> vector_iterator_next(it) == lib.GxB_EXHAUSTED + True + + """ + info = lib.GxB_Vector_Iterator_next(it[0]) + return _check_info(info) + + +def vector_iterator_get_index(it): + """Get the current index of the vector iterator.""" + return lib.GxB_Vector_Iterator_getIndex(it[0]) + + +def vector_iterator_getp(it): + """Get the current position of the vector iterator.""" + return lib.GxB_Vector_Iterator_getp(it[0]) + + +def vector_iterator_getpmax(it): + """Get the maximum position of the vector iterator.""" + return lib.GxB_Vector_Iterator_getpmax(it[0]) + + +# --------------------------------------------------------------------------- +# Value getters (shared across all iteration modes) +# --------------------------------------------------------------------------- + + +def iterator_get_bool(it): + """Get the current boolean value from the iterator.""" + return lib.GxB_Iterator_get_BOOL(it[0]) + + +def iterator_get_int8(it): + """Get the current int8 value from the iterator.""" + return lib.GxB_Iterator_get_INT8(it[0]) + + +def iterator_get_int16(it): + """Get the current int16 value from the iterator.""" + return lib.GxB_Iterator_get_INT16(it[0]) + + +def iterator_get_int32(it): + """Get the current int32 value from the iterator.""" + return lib.GxB_Iterator_get_INT32(it[0]) + + +def iterator_get_int64(it): + """Get the current int64 value from the iterator.""" + return lib.GxB_Iterator_get_INT64(it[0]) + + +def iterator_get_uint8(it): + """Get the current uint8 value from the iterator.""" + return lib.GxB_Iterator_get_UINT8(it[0]) + + +def iterator_get_uint16(it): + """Get the current uint16 value from the iterator.""" + return lib.GxB_Iterator_get_UINT16(it[0]) + + +def iterator_get_uint32(it): + """Get the current uint32 value from the iterator.""" + return lib.GxB_Iterator_get_UINT32(it[0]) + + +def iterator_get_uint64(it): + """Get the current uint64 value from the iterator.""" + return lib.GxB_Iterator_get_UINT64(it[0]) + + +def iterator_get_fp32(it): + """Get the current fp32 value from the iterator.""" + return lib.GxB_Iterator_get_FP32(it[0]) + + +def iterator_get_fp64(it): + """Get the current fp64 value from the iterator.""" + return lib.GxB_Iterator_get_FP64(it[0]) + + +if supports_complex(): + + def iterator_get_fc32(it): + """Get the current fc32 value from the iterator.""" + return lib.GxB_Iterator_get_FC32(it[0]) + + def iterator_get_fc64(it): + """Get the current fc64 value from the iterator.""" + return lib.GxB_Iterator_get_FC64(it[0]) diff --git a/suitesparse_graphblas/api/matrix.py b/suitesparse_graphblas/api/matrix.py new file mode 100644 index 0000000..157d733 --- /dev/null +++ b/suitesparse_graphblas/api/matrix.py @@ -0,0 +1,2036 @@ +"""Create, manipulate, and query GrB_Matrix objects.""" + +import numpy as np + +from suitesparse_graphblas import check_status, ffi, lib, supports_complex + +from .io.serialize import deserialize_matrix as deserialize # noqa: F401 +from .io.serialize import serialize_matrix as serialize # noqa: F401 +from .utils import _capture_c_output # noqa: F401 + + +def matrix_free(A): + """Free a matrix.""" + check_status(A, lib.GrB_Matrix_free(A)) + + +def matrix_new(T, nrows=lib.GxB_INDEX_MAX, ncols=lib.GxB_INDEX_MAX, *, free=matrix_free): + """Create a new `GrB_Matrix` of type `T` and initialize it. The + following example creates an eight bit unsigned 2x2 matrix: + + >>> A = matrix_new(lib.GrB_UINT8, 2, 2) + >>> matrix_shape(A) + (2, 2) + + The default value for `nrows` and `ncols` is `lib.GxB_INDEX_MAX` + which creates a Matrix with maximal bounds: + + >>> A = matrix_new(lib.GrB_UINT8) + >>> matrix_shape(A) == (lib.GxB_INDEX_MAX, lib.GxB_INDEX_MAX) + True + + The `free` argument is called when the object is garbage + collected, the default is `matrix.matrix_free()`. If `free` is None then + there is no automatic garbage collection and it is up to the user + to free the matrix. + + """ + A = ffi.new("GrB_Matrix*") + check_status(A, lib.GrB_Matrix_new(A, T, nrows, ncols)) + if free: + return ffi.gc(A, free) + return A + + +def matrix_type(A): + """Return the GraphBLAS type of the vector. + + >>> A = matrix_new(lib.GrB_UINT8) + >>> matrix_type(A) == lib.GrB_UINT8 + True + + """ + T = ffi.new("GrB_Type*") + check_status(A, lib.GxB_Matrix_type(T, A[0])) + return T[0] + + +def matrix_nrows(A): + """Return the number of rows in the matrix. + + >>> A = matrix_new(lib.GrB_UINT8, 2, 3) + >>> matrix_nrows(A) + 2 + + """ + n = ffi.new("GrB_Index*") + check_status(A, lib.GrB_Matrix_nrows(n, A[0])) + return n[0] + + +def matrix_ncols(A): + """Return the number of columns in the matrix. + + >>> A = matrix_new(lib.GrB_UINT8, 2, 3) + >>> matrix_ncols(A) + 3 + + """ + n = ffi.new("GrB_Index*") + check_status(A, lib.GrB_Matrix_ncols(n, A[0])) + return n[0] + + +def matrix_nvals(A): + """Return the number of stored elements in the matrix. + + >>> A = matrix_new(lib.GrB_UINT8, 2, 3) + >>> matrix_nvals(A) + 0 + + """ + n = ffi.new("GrB_Index*") + check_status(A, lib.GrB_Matrix_nvals(n, A[0])) + return n[0] + + +def matrix_shape(A): + """Return the shape of the matrix as a two tuple `(nrows, ncols)` + + >>> A = matrix_new(lib.GrB_UINT8, 2, 2) + >>> matrix_shape(A) + (2, 2) + + """ + return (matrix_nrows(A), matrix_ncols(A)) + + +def matrix_format(A): + """Return the format of the matrix. + + >>> A = matrix_new(lib.GrB_UINT8, 2, 2) + >>> matrix_format(A) == lib.GxB_BY_ROW + True + + """ + format = ffi.new("int32_t*") + check_status(A, lib.GxB_Matrix_Option_get_INT32(A[0], lib.GxB_FORMAT, format)) + return format[0] + + +def matrix_set_format(A, format): + """Set the format of the matrix. + + >>> A = matrix_new(lib.GrB_UINT8, 2, 2) + >>> matrix_set_format(A, lib.GxB_BY_COL) + >>> matrix_format(A) == lib.GxB_BY_COL + True + + """ + format_val = ffi.cast("int32_t", format) + check_status(A, lib.GxB_Matrix_Option_set_INT32(A[0], lib.GxB_FORMAT, format_val)) + + +def matrix_sparsity_status(A): + """Get the sparsity status of the matrix.""" + sparsity_status = ffi.new("int32_t*") + check_status(A, lib.GxB_Matrix_Option_get_INT32(A[0], lib.GxB_SPARSITY_STATUS, sparsity_status)) + return sparsity_status[0] + + +def matrix_sparsity_control(A): + """Get the sparsity control of the matrix.""" + sparsity_control = ffi.new("int32_t*") + check_status( + A, lib.GxB_Matrix_Option_get_INT32(A[0], lib.GxB_SPARSITY_CONTROL, sparsity_control) + ) + return sparsity_control[0] + + +def matrix_set_sparsity_control(A, sparsity): + """Set the sparsity control of the matrix.""" + sparsity_control = ffi.cast("int32_t", sparsity) + check_status( + A, lib.GxB_Matrix_Option_set_INT32(A[0], lib.GxB_SPARSITY_CONTROL, sparsity_control) + ) + + +def matrix_hyper_switch(A): + """Get the hyper switch of the matrix.""" + hyper_switch = ffi.new("double*") + check_status(A, lib.GxB_Matrix_Option_get_FP64(A[0], lib.GxB_HYPER_SWITCH, hyper_switch)) + return hyper_switch[0] + + +def matrix_set_hyper_switch(A, hyper_switch): + """Set the hyper switch of the matrix.""" + hyper_switch = ffi.cast("double", hyper_switch) + check_status(A, lib.GxB_Matrix_Option_set_FP64(A[0], lib.GxB_HYPER_SWITCH, hyper_switch)) + + +def matrix_bitmap_switch(A): + """Get the bitmap switch of the matrix.""" + bitmap_switch = ffi.new("double*") + check_status(A, lib.GxB_Matrix_Option_get_FP64(A[0], lib.GxB_BITMAP_SWITCH, bitmap_switch)) + return bitmap_switch[0] + + +def matrix_set_bitmap_switch(A, bitmap_switch): + """Set the bitmap switch of the matrix.""" + bitmap_switch = ffi.cast("double", bitmap_switch) + check_status(A, lib.GxB_Matrix_Option_set_FP64(A[0], lib.GxB_BITMAP_SWITCH, bitmap_switch)) + + +def matrix_option_get_int32(A, field): + """Get a matrix option as an int32. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix_option_get_int32(A, lib.GxB_FORMAT) == lib.GxB_BY_ROW + True + + """ + val = ffi.new("int32_t*") + check_status(A, lib.GxB_Matrix_Option_get_INT32(A[0], field, val)) + return val[0] + + +def matrix_option_set_int32(A, field, value): + """Set a matrix option from an int32. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix_option_set_int32(A, lib.GxB_FORMAT, lib.GxB_BY_COL) + >>> matrix_option_get_int32(A, lib.GxB_FORMAT) == lib.GxB_BY_COL + True + + """ + check_status( + A, + lib.GxB_Matrix_Option_set_INT32( + A[0], + field, + ffi.cast("int32_t", value), + ), + ) + + +def matrix_option_get_fp64(A, field): + """Get a matrix option as a float64. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> isinstance(matrix_option_get_fp64(A, lib.GxB_HYPER_SWITCH), float) + True + + """ + val = ffi.new("double*") + check_status(A, lib.GxB_Matrix_Option_get_FP64(A[0], field, val)) + return val[0] + + +def matrix_option_set_fp64(A, field, value): + """Set a matrix option from a float64. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix_option_set_fp64(A, lib.GxB_HYPER_SWITCH, 0.5) + >>> matrix_option_get_fp64(A, lib.GxB_HYPER_SWITCH) == 0.5 + True + + """ + check_status( + A, + lib.GxB_Matrix_Option_set_FP64( + A[0], + field, + ffi.cast("double", value), + ), + ) + + +# --------------------------------------------------------------------------- +# GraphBLAS operations +# --------------------------------------------------------------------------- + + +def matrix_dup(A, *, free=matrix_free): + """Duplicate a matrix. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 42, 0, 0) + >>> B = matrix_dup(A) + >>> get_int64(B, 0, 0) == 42 + True + + """ + C = ffi.new("GrB_Matrix*") + check_status(C, lib.GrB_Matrix_dup(C, A[0])) + if free: + return ffi.gc(C, free) + return C + + +def matrix_clear(A): + """Remove all entries from a matrix. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 42, 0, 0) + >>> matrix_nvals(A) == 1 + True + >>> matrix_clear(A) + >>> matrix_nvals(A) == 0 + True + + """ + check_status(A, lib.GrB_Matrix_clear(A[0])) + + +def matrix_wait(A, waitmode=lib.GrB_COMPLETE): + """Wait for a matrix to complete pending operations. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix_wait(A) + + """ + check_status(A, lib.GrB_Matrix_wait(A[0], waitmode)) + + +def matrix_print(A, name="", level=lib.GxB_COMPLETE): + """Print a matrix to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 42, 0, 0) + >>> matrix_wait(A, lib.GrB_MATERIALIZE) + >>> out = _capture_c_output(matrix_print, A, 'A', lib.GxB_SHORT) + >>> '2x2 GraphBLAS int64_t matrix' in out + True + >>> '(0,0) 42' in out + True + + """ + check_status( + A, + lib.GxB_Matrix_fprint( + A[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def matrix_fprint(A, f, name="", level=lib.GxB_COMPLETE): + """Print a matrix to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`matrix_print`). + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 7, 1, 1) + >>> matrix_wait(A, lib.GrB_MATERIALIZE) + >>> out = _capture_c_output(matrix_fprint, A, ffi.NULL, 'A', lib.GxB_SHORT) + >>> '2x2 GraphBLAS int64_t matrix' in out + True + >>> '(1,1) 7' in out + True + + """ + check_status( + A, + lib.GxB_Matrix_fprint( + A[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +def matrix_mxm(C, semiring, A, B, mask=None, accum=None, desc=None): + """Multiply two matrices using a semiring: C = A (+.*) B. + + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> B = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(B, 3, 0, 0) + >>> matrix_mxm(C, lib.GrB_PLUS_TIMES_SEMIRING_INT64, A, B) + >>> get_int64(C, 0, 0) == 6 + True + + """ + check_status( + C, + lib.GrB_mxm( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + semiring, + A[0], + B[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_ewise_add(C, op, A, B, mask=None, accum=None, desc=None): + """Element-wise addition of two matrices using a binary operator. + + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> B = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(B, 3, 0, 0) + >>> matrix_ewise_add(C, lib.GrB_PLUS_INT64, A, B) + >>> get_int64(C, 0, 0) == 5 + True + + """ + check_status( + C, + lib.GrB_Matrix_eWiseAdd_BinaryOp( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + B[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_ewise_mult(C, op, A, B, mask=None, accum=None, desc=None): + """Element-wise multiplication of two matrices using a binary operator. + + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> B = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(B, 3, 0, 0) + >>> matrix_ewise_mult(C, lib.GrB_TIMES_INT64, A, B) + >>> get_int64(C, 0, 0) == 6 + True + + """ + check_status( + C, + lib.GrB_Matrix_eWiseMult_BinaryOp( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + B[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_ewise_union(C, op, A, alpha, B, beta, mask=None, accum=None, desc=None): + """Element-wise union of two matrices using a binary operator. + + Unlike eWiseAdd, entries present in only one operand use the + corresponding default scalar (``alpha`` for A, ``beta`` for B). + + >>> from suitesparse_graphblas import scalar + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> B = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(B, 3, 1, 1) + >>> a = scalar.scalar_new(lib.GrB_INT64) + >>> b = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(a, 0) + >>> scalar.set_int64(b, 0) + >>> matrix_ewise_union(C, lib.GrB_PLUS_INT64, A, a, B, b) + >>> get_int64(C, 0, 0) == 2 + True + >>> get_int64(C, 1, 1) == 3 + True + + """ + check_status( + C, + lib.GxB_Matrix_eWiseUnion( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + alpha[0], + B[0], + beta[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_apply(C, op, A, mask=None, accum=None, desc=None): + """Apply a unary operator to each entry of a matrix. + + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, -5, 0, 0) + >>> matrix_apply(C, lib.GrB_ABS_INT64, A) + >>> get_int64(C, 0, 0) == 5 + True + + """ + check_status( + C, + lib.GrB_Matrix_apply( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_apply_first(C, op, x, A, mask=None, accum=None, desc=None): + """Apply a binary operator with a scalar bound to the first argument: C = op(x, A). + + >>> from suitesparse_graphblas import scalar + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 3, 0, 0) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 10) + >>> matrix_apply_first(C, lib.GrB_TIMES_INT64, s, A) + >>> get_int64(C, 0, 0) == 30 + True + + """ + check_status( + C, + lib.GrB_Matrix_apply_BinaryOp1st_Scalar( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + x[0], + A[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_apply_second(C, op, A, y, mask=None, accum=None, desc=None): + """Apply a binary operator with a scalar bound to the second argument: C = op(A, y). + + >>> from suitesparse_graphblas import scalar + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 10, 0, 0) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 3) + >>> matrix_apply_second(C, lib.GrB_TIMES_INT64, A, s) + >>> get_int64(C, 0, 0) == 30 + True + + """ + check_status( + C, + lib.GrB_Matrix_apply_BinaryOp2nd_Scalar( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + y[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_apply_indexop(C, op, A, thunk, mask=None, accum=None, desc=None): + """Apply an index unary operator to each entry of a matrix with a scalar thunk. + + >>> from suitesparse_graphblas import scalar + >>> C = matrix_new(lib.GrB_INT64, 3, 3) + >>> A = matrix_new(lib.GrB_INT64, 3, 3) + >>> set_int64(A, 10, 0, 0) + >>> set_int64(A, 20, 1, 1) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 0) + >>> matrix_apply_indexop(C, lib.GrB_ROWINDEX_INT64, A, s) + >>> get_int64(C, 0, 0) == 0 + True + >>> get_int64(C, 1, 1) == 1 + True + + """ + check_status( + C, + lib.GrB_Matrix_apply_IndexOp_Scalar( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + thunk[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_select(C, op, A, thunk, mask=None, accum=None, desc=None): + """Select entries from a matrix using an index unary operator and scalar thunk. + + >>> from suitesparse_graphblas import scalar + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 5, 0, 0) + >>> set_int64(A, 1, 1, 1) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 3) + >>> matrix_select(C, lib.GrB_VALUEGT_INT64, A, s) + >>> matrix_nvals(C) == 1 + True + >>> get_int64(C, 0, 0) == 5 + True + + """ + check_status( + C, + lib.GrB_Matrix_select_Scalar( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + thunk[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_reduce(w, monoid, A, mask=None, accum=None, desc=None): + """Reduce a matrix to a vector using a monoid (row-wise reduction). + + >>> from suitesparse_graphblas import vector + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(A, 3, 0, 1) + >>> w = vector.vector_new(lib.GrB_INT64, 2) + >>> matrix_reduce(w, lib.GrB_PLUS_MONOID_INT64, A) + >>> vector.get_int64(w, 0) == 5 + True + + """ + check_status( + w, + lib.GrB_Matrix_reduce_Monoid( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + monoid, + A[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_reduce_scalar(s, monoid, A, accum=None, desc=None): + """Reduce a matrix to a scalar using a monoid. + + >>> from suitesparse_graphblas import scalar + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(A, 3, 1, 1) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> matrix_reduce_scalar(s, lib.GrB_PLUS_MONOID_INT64, A) + >>> scalar.get_int64(s) == 5 + True + + """ + check_status( + s, + lib.GrB_Matrix_reduce_Monoid_Scalar( + s[0], + ffi.NULL if accum is None else accum, + monoid, + A[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_transpose(C, A, mask=None, accum=None, desc=None): + """Transpose a matrix. + + >>> C = matrix_new(lib.GrB_INT64, 3, 2) + >>> A = matrix_new(lib.GrB_INT64, 2, 3) + >>> set_int64(A, 7, 0, 2) + >>> matrix_transpose(C, A) + >>> get_int64(C, 2, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_transpose( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + A[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_kronecker(C, op, A, B, mask=None, accum=None, desc=None): + """Kronecker product of two matrices using a binary operator. + + >>> C = matrix_new(lib.GrB_INT64, 4, 4) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> B = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 2, 0, 0) + >>> set_int64(B, 3, 0, 0) + >>> matrix_kronecker(C, lib.GrB_TIMES_INT64, A, B) + >>> get_int64(C, 0, 0) == 6 + True + + """ + check_status( + C, + lib.GrB_Matrix_kronecker_BinaryOp( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + A[0], + B[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_diag(C, v, k=0, desc=None): + """Build a diagonal matrix from a vector. + + The vector ``v`` is placed on the ``k``-th diagonal of ``C`` + (``k=0`` is the main diagonal, positive is above, negative below). + + >>> from suitesparse_graphblas import vector + >>> C = matrix_new(lib.GrB_INT64, 3, 3) + >>> v = vector.vector_new(lib.GrB_INT64, 3) + >>> vector.set_int64(v, 1, 0) + >>> vector.set_int64(v, 2, 1) + >>> vector.set_int64(v, 3, 2) + >>> matrix_diag(C, v, 0) + >>> get_int64(C, 0, 0) == 1 + True + >>> get_int64(C, 1, 1) == 2 + True + >>> get_int64(C, 2, 2) == 3 + True + + """ + check_status( + C, + lib.GxB_Matrix_diag( + C[0], + v[0], + k, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_concat(C, tiles, m, n, desc=None): + """Concatenate an m-by-n grid of tile matrices into C. + + ``tiles`` is a flat list of matrix handles in row-major order, + representing an m-by-n grid of submatrices. + + >>> A = matrix_new(lib.GrB_INT64, 1, 2) + >>> B = matrix_new(lib.GrB_INT64, 1, 2) + >>> set_int64(A, 1, 0, 0) + >>> set_int64(A, 2, 0, 1) + >>> set_int64(B, 3, 0, 0) + >>> set_int64(B, 4, 0, 1) + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> matrix_concat(C, [A, B], 2, 1) + >>> get_int64(C, 0, 0) == 1 + True + >>> get_int64(C, 1, 0) == 3 + True + + """ + tile_array = ffi.new("GrB_Matrix[]", [t[0] for t in tiles]) + check_status( + C, + lib.GxB_Matrix_concat( + C[0], + tile_array, + m, + n, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_assign(C, A, rows, nrows, cols, ncols, mask=None, accum=None, desc=None): + """Assign a submatrix: C[rows, cols] = A. + + >>> C = matrix_new(lib.GrB_INT64, 3, 3) + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 10, 0, 0) + >>> set_int64(A, 20, 1, 1) + >>> rows = ffi.new("GrB_Index[2]", [0, 1]) + >>> cols = ffi.new("GrB_Index[2]", [0, 1]) + >>> matrix_assign(C, A, rows, 2, cols, 2) + >>> get_int64(C, 0, 0) == 10 + True + >>> get_int64(C, 1, 1) == 20 + True + + """ + check_status( + C, + lib.GrB_Matrix_assign( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + A[0], + rows, + nrows, + cols, + ncols, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_assign_scalar(C, x, rows, nrows, cols, ncols, mask=None, accum=None, desc=None): + """Assign a scalar to a submatrix: C[rows, cols] = x. + + >>> from suitesparse_graphblas import scalar + >>> C = matrix_new(lib.GrB_INT64, 3, 3) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 99) + >>> rows = ffi.new("GrB_Index[2]", [0, 1]) + >>> cols = ffi.new("GrB_Index[2]", [0, 1]) + >>> matrix_assign_scalar(C, s, rows, 2, cols, 2) + >>> get_int64(C, 0, 0) == 99 + True + >>> get_int64(C, 1, 1) == 99 + True + + """ + check_status( + C, + lib.GrB_Matrix_assign_Scalar( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + x[0], + rows, + nrows, + cols, + ncols, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_extract(C, A, rows, nrows, cols, ncols, mask=None, accum=None, desc=None): + """Extract a submatrix: C = A[rows, cols]. + + >>> A = matrix_new(lib.GrB_INT64, 3, 3) + >>> set_int64(A, 42, 1, 2) + >>> C = matrix_new(lib.GrB_INT64, 1, 1) + >>> rows = ffi.new("GrB_Index[1]", [1]) + >>> cols = ffi.new("GrB_Index[1]", [2]) + >>> matrix_extract(C, A, rows, 1, cols, 1) + >>> get_int64(C, 0, 0) == 42 + True + + """ + check_status( + C, + lib.GrB_Matrix_extract( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + A[0], + rows, + nrows, + cols, + ncols, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_col_extract(w, A, rows, nrows, j, mask=None, accum=None, desc=None): + """Extract a column from a matrix into a vector: w = A[rows, j]. + + >>> from suitesparse_graphblas import vector + >>> A = matrix_new(lib.GrB_INT64, 3, 3) + >>> set_int64(A, 42, 1, 2) + >>> w = vector.vector_new(lib.GrB_INT64, 3) + >>> matrix_col_extract(w, A, lib.GrB_ALL, 3, 2) + >>> vector.get_int64(w, 1) == 42 + True + + """ + check_status( + w, + lib.GrB_Col_extract( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + A[0], + rows, + nrows, + j, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_col_assign(C, u, rows, nrows, j, mask=None, accum=None, desc=None): + """Assign a vector to a column of a matrix: C[rows, j] = u. + + >>> from suitesparse_graphblas import vector + >>> C = matrix_new(lib.GrB_INT64, 3, 3) + >>> u = vector.vector_new(lib.GrB_INT64, 3) + >>> vector.set_int64(u, 42, 1) + >>> matrix_col_assign(C, u, lib.GrB_ALL, 3, 2) + >>> get_int64(C, 1, 2) == 42 + True + + """ + check_status( + C, + lib.GrB_Col_assign( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + u[0], + rows, + nrows, + j, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_row_assign(C, u, i, cols, ncols, mask=None, accum=None, desc=None): + """Assign a vector to a row of a matrix: C[i, cols] = u. + + >>> from suitesparse_graphblas import vector + >>> C = matrix_new(lib.GrB_INT64, 3, 3) + >>> u = vector.vector_new(lib.GrB_INT64, 3) + >>> vector.set_int64(u, 42, 1) + >>> matrix_row_assign(C, u, 2, lib.GrB_ALL, 3) + >>> get_int64(C, 2, 1) == 42 + True + + """ + check_status( + C, + lib.GrB_Row_assign( + C[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + u[0], + i, + cols, + ncols, + ffi.NULL if desc is None else desc, + ), + ) + + +def matrix_build_bool(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of boolean values. + + >>> C = matrix_new(lib.GrB_BOOL, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([True], dtype=np.bool_) + >>> matrix_build_bool(C, rows, cols, vals, 1, lib.GrB_FIRST_BOOL) + >>> get_bool(C, 0, 0) == True + True + + """ + check_status( + C, + lib.GrB_Matrix_build_BOOL( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("bool*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_int8(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of int8 values. + + >>> C = matrix_new(lib.GrB_INT8, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int8) + >>> matrix_build_int8(C, rows, cols, vals, 1, lib.GrB_PLUS_INT8) + >>> get_int8(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_INT8( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int8_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_int16(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of int16 values. + + >>> C = matrix_new(lib.GrB_INT16, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int16) + >>> matrix_build_int16(C, rows, cols, vals, 1, lib.GrB_PLUS_INT16) + >>> get_int16(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_INT16( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int16_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_int32(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of int32 values. + + >>> C = matrix_new(lib.GrB_INT32, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int32) + >>> matrix_build_int32(C, rows, cols, vals, 1, lib.GrB_PLUS_INT32) + >>> get_int32(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_INT32( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int32_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_int64(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of int64 values. + + >>> C = matrix_new(lib.GrB_INT64, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int64) + >>> matrix_build_int64(C, rows, cols, vals, 1, lib.GrB_PLUS_INT64) + >>> get_int64(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_INT64( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int64_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_uint8(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of uint8 values. + + >>> C = matrix_new(lib.GrB_UINT8, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint8) + >>> matrix_build_uint8(C, rows, cols, vals, 1, lib.GrB_PLUS_UINT8) + >>> get_uint8(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_UINT8( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint8_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_uint16(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of uint16 values. + + >>> C = matrix_new(lib.GrB_UINT16, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint16) + >>> matrix_build_uint16(C, rows, cols, vals, 1, lib.GrB_PLUS_UINT16) + >>> get_uint16(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_UINT16( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint16_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_uint32(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of uint32 values. + + >>> C = matrix_new(lib.GrB_UINT32, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint32) + >>> matrix_build_uint32(C, rows, cols, vals, 1, lib.GrB_PLUS_UINT32) + >>> get_uint32(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_UINT32( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint32_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_uint64(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of uint64 values. + + >>> C = matrix_new(lib.GrB_UINT64, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint64) + >>> matrix_build_uint64(C, rows, cols, vals, 1, lib.GrB_PLUS_UINT64) + >>> get_uint64(C, 0, 0) == 7 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_UINT64( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint64_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_fp32(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of fp32 values. + + >>> C = matrix_new(lib.GrB_FP32, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([1.5], dtype=np.float32) + >>> matrix_build_fp32(C, rows, cols, vals, 1, lib.GrB_PLUS_FP32) + >>> get_fp32(C, 0, 0) == 1.5 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_FP32( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("float*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_build_fp64(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of fp64 values. + + >>> C = matrix_new(lib.GrB_FP64, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([1.5], dtype=np.float64) + >>> matrix_build_fp64(C, rows, cols, vals, 1, lib.GrB_PLUS_FP64) + >>> get_fp64(C, 0, 0) == 1.5 + True + + """ + check_status( + C, + lib.GrB_Matrix_build_FP64( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("double*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def matrix_extract_tuples_int64(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(A, 42, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_int64(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 42 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_INT64( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int64_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_fp64(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_FP64, 2, 2) + >>> set_fp64(A, 1.5, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_fp64(A) + >>> len(vals) == 1 + True + >>> float(vals[0]) == 1.5 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.float64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_FP64( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("double*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_bool(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_BOOL, 2, 2) + >>> set_bool(A, True, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_bool(A) + >>> len(vals) == 1 + True + >>> bool(vals[0]) == True + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.bool_) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_BOOL( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("bool*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_int8(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_INT8, 2, 2) + >>> set_int8(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_int8(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int8) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_INT8( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int8_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_int16(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_INT16, 2, 2) + >>> set_int16(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_int16(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int16) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_INT16( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int16_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_int32(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_INT32, 2, 2) + >>> set_int32(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_int32(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int32) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_INT32( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("int32_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_uint8(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_UINT8, 2, 2) + >>> set_uint8(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_uint8(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint8) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_UINT8( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint8_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_uint16(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_UINT16, 2, 2) + >>> set_uint16(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_uint16(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint16) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_UINT16( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint16_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_uint32(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_UINT32, 2, 2) + >>> set_uint32(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_uint32(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint32) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_UINT32( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint32_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_uint64(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_UINT64, 2, 2) + >>> set_uint64(A, 7, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_uint64(A) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_UINT64( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("uint64_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def matrix_extract_tuples_fp32(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GrB_FP32, 2, 2) + >>> set_fp32(A, 1.5, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_fp32(A) + >>> len(vals) == 1 + True + >>> float(vals[0]) == 1.5 + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.float32) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GrB_Matrix_extractTuples_FP32( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("float*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + +def set_bool(A, value, i, j): + """Set a boolean value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_BOOL, 3, 3) + >>> set_bool(A, True, 2, 2) + >>> get_bool(A, 2, 2) == True + True + + """ + check_status(A, lib.GrB_Matrix_setElement_BOOL(A[0], value, i, j)) + + +def get_bool(A, i, j): + """Get a boolean value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_BOOL, 3, 3) + >>> set_bool(A, True, 2, 2) + >>> get_bool(A, 2, 2) == True + True + + """ + value = ffi.new("bool*") + check_status(A, lib.GrB_Matrix_extractElement_BOOL(value, A[0], i, j)) + return value[0] + + +def set_int8(A, value, i, j): + """Set an int8 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT8, 3, 3) + >>> set_int8(A, 7, 2, 2) + >>> get_int8(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_INT8(A[0], value, i, j)) + + +def get_int8(A, i, j): + """Get an int8 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT8, 3, 3) + >>> set_int8(A, 7, 2, 2) + >>> get_int8(A, 2, 2) == 7 + True + + """ + value = ffi.new("int8_t*") + check_status(A, lib.GrB_Matrix_extractElement_INT8(value, A[0], i, j)) + return value[0] + + +def set_int16(A, value, i, j): + """Set an int16 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT16, 3, 3) + >>> set_int16(A, 7, 2, 2) + >>> get_int16(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_INT16(A[0], value, i, j)) + + +def get_int16(A, i, j): + """Get an int16 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT16, 3, 3) + >>> set_int16(A, 7, 2, 2) + >>> get_int16(A, 2, 2) == 7 + True + + """ + value = ffi.new("int16_t*") + check_status(A, lib.GrB_Matrix_extractElement_INT16(value, A[0], i, j)) + return value[0] + + +def set_int32(A, value, i, j): + """Set an int32 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT32, 3, 3) + >>> set_int32(A, 7, 2, 2) + >>> get_int32(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_INT32(A[0], value, i, j)) + + +def get_int32(A, i, j): + """Get an int32 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT32, 3, 3) + >>> set_int32(A, 7, 2, 2) + >>> get_int32(A, 2, 2) == 7 + True + + """ + value = ffi.new("int32_t*") + check_status(A, lib.GrB_Matrix_extractElement_INT32(value, A[0], i, j)) + return value[0] + + +def set_int64(A, value, i, j): + """Set an int64 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT64, 3, 3) + >>> set_int64(A, 7, 2, 2) + >>> get_int64(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_INT64(A[0], value, i, j)) + + +def get_int64(A, i, j): + """Get an int64 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_INT64, 3, 3) + >>> set_int64(A, 7, 2, 2) + >>> get_int64(A, 2, 2) == 7 + True + + """ + value = ffi.new("int64_t*") + check_status(A, lib.GrB_Matrix_extractElement_INT64(value, A[0], i, j)) + return value[0] + + +def set_uint8(A, value, i, j): + """Set a uint8 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT8, 3, 3) + >>> set_uint8(A, 7, 2, 2) + >>> get_uint8(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_UINT8(A[0], value, i, j)) + + +def get_uint8(A, i, j): + """Get a uint8 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT8, 3, 3) + >>> set_uint8(A, 7, 2, 2) + >>> get_uint8(A, 2, 2) == 7 + True + + """ + value = ffi.new("uint8_t*") + check_status(A, lib.GrB_Matrix_extractElement_UINT8(value, A[0], i, j)) + return value[0] + + +def set_uint16(A, value, i, j): + """Set a uint16 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT16, 3, 3) + >>> set_uint16(A, 7, 2, 2) + >>> get_uint16(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_UINT16(A[0], value, i, j)) + + +def get_uint16(A, i, j): + """Get a uint16 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT16, 3, 3) + >>> set_uint16(A, 7, 2, 2) + >>> get_uint16(A, 2, 2) == 7 + True + + """ + value = ffi.new("uint16_t*") + check_status(A, lib.GrB_Matrix_extractElement_UINT16(value, A[0], i, j)) + return value[0] + + +def set_uint32(A, value, i, j): + """Set a uint32 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT32, 3, 3) + >>> set_uint32(A, 7, 2, 2) + >>> get_uint32(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_UINT32(A[0], value, i, j)) + + +def get_uint32(A, i, j): + """Get a uint32 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT32, 3, 3) + >>> set_uint32(A, 7, 2, 2) + >>> get_uint32(A, 2, 2) == 7 + True + + """ + value = ffi.new("uint32_t*") + check_status(A, lib.GrB_Matrix_extractElement_UINT32(value, A[0], i, j)) + return value[0] + + +def set_uint64(A, value, i, j): + """Set a uint64 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT64, 3, 3) + >>> set_uint64(A, 7, 2, 2) + >>> get_uint64(A, 2, 2) == 7 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_UINT64(A[0], value, i, j)) + + +def get_uint64(A, i, j): + """Get a uint64 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_UINT64, 3, 3) + >>> set_uint64(A, 7, 2, 2) + >>> get_uint64(A, 2, 2) == 7 + True + + """ + value = ffi.new("uint64_t*") + check_status(A, lib.GrB_Matrix_extractElement_UINT64(value, A[0], i, j)) + return value[0] + + +def set_fp32(A, value, i, j): + """Set an fp32 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_FP32, 3, 3) + >>> set_fp32(A, 1.5, 2, 2) + >>> get_fp32(A, 2, 2) == 1.5 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_FP32(A[0], value, i, j)) + + +def get_fp32(A, i, j): + """Get an fp32 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_FP32, 3, 3) + >>> set_fp32(A, 1.5, 2, 2) + >>> get_fp32(A, 2, 2) == 1.5 + True + + """ + value = ffi.new("float*") + check_status(A, lib.GrB_Matrix_extractElement_FP32(value, A[0], i, j)) + return value[0] + + +def set_fp64(A, value, i, j): + """Set an fp64 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_FP64, 3, 3) + >>> set_fp64(A, 1.5, 2, 2) + >>> get_fp64(A, 2, 2) == 1.5 + True + + """ + check_status(A, lib.GrB_Matrix_setElement_FP64(A[0], value, i, j)) + + +def get_fp64(A, i, j): + """Get an fp64 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GrB_FP64, 3, 3) + >>> set_fp64(A, 1.5, 2, 2) + >>> get_fp64(A, 2, 2) == 1.5 + True + + """ + value = ffi.new("double*") + check_status(A, lib.GrB_Matrix_extractElement_FP64(value, A[0], i, j)) + return value[0] + + +if supports_complex(): + + def set_fc32(A, value, i, j): + """Set an fc32 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GxB_FC32, 3, 3) + >>> set_fc32(A, 2+3j, 2, 2) + >>> get_fc32(A, 2, 2) == 2+3j + True + + """ + check_status(A, lib.GxB_Matrix_setElement_FC32(A[0], value, i, j)) + + def get_fc32(A, i, j): + """Get an fc32 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GxB_FC32, 3, 3) + >>> set_fc32(A, 2+3j, 2, 2) + >>> get_fc32(A, 2, 2) == 2+3j + True + + """ + value = ffi.new("GxB_FC32_t*") + check_status(A, lib.GxB_Matrix_extractElement_FC32(value, A[0], i, j)) + return value[0] + + def set_fc64(A, value, i, j): + """Set an fc64 value to the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GxB_FC64, 3, 3) + >>> set_fc64(A, 2+3j, 2, 2) + >>> get_fc64(A, 2, 2) == 2+3j + True + + """ + check_status(A, lib.GxB_Matrix_setElement_FC64(A[0], value, i, j)) + + def get_fc64(A, i, j): + """Get an fc64 value from the matrix at row `i` column `j`. + + >>> A = matrix_new(lib.GxB_FC64, 3, 3) + >>> set_fc64(A, 2+3j, 2, 2) + >>> get_fc64(A, 2, 2) == 2+3j + True + + """ + value = ffi.new("GxB_FC64_t*") + check_status(A, lib.GxB_Matrix_extractElement_FC64(value, A[0], i, j)) + return value[0] + + def matrix_build_fc32(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of fc32 values. + + >>> C = matrix_new(lib.GxB_FC32, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([2+3j], dtype=np.complex64) + >>> matrix_build_fc32(C, rows, cols, vals, 1, lib.GxB_PLUS_FC32) + >>> get_fc32(C, 0, 0) == 2+3j + True + + """ + check_status( + C, + lib.GxB_Matrix_build_FC32( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("GxB_FC32_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + def matrix_extract_tuples_fc32(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GxB_FC32, 2, 2) + >>> set_fc32(A, 2+3j, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_fc32(A) + >>> len(vals) == 1 + True + >>> complex(vals[0]) == 2+3j + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.complex64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GxB_Matrix_extractTuples_FC32( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("GxB_FC32_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals + + def matrix_build_fc64(C, rows, cols, vals, nvals, dup): + """Build a matrix from COO arrays of fc64 values. + + >>> C = matrix_new(lib.GxB_FC64, 2, 2) + >>> rows = np.array([0], dtype=np.uint64) + >>> cols = np.array([0], dtype=np.uint64) + >>> vals = np.array([2+3j], dtype=np.complex128) + >>> matrix_build_fc64(C, rows, cols, vals, 1, lib.GxB_PLUS_FC64) + >>> get_fc64(C, 0, 0) == 2+3j + True + + """ + check_status( + C, + lib.GxB_Matrix_build_FC64( + C[0], + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("GxB_FC64_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + def matrix_extract_tuples_fc64(A): + """Extract all tuples from a matrix as numpy arrays. + + Returns (rows, cols, vals) as numpy arrays. + + >>> A = matrix_new(lib.GxB_FC64, 2, 2) + >>> set_fc64(A, 2+3j, 0, 0) + >>> rows, cols, vals = matrix_extract_tuples_fc64(A) + >>> len(vals) == 1 + True + >>> complex(vals[0]) == 2+3j + True + + """ + n = matrix_nvals(A) + rows = np.empty(n, dtype=np.uint64) + cols = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.complex128) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + A, + lib.GxB_Matrix_extractTuples_FC64( + ffi.cast("GrB_Index*", ffi.from_buffer(rows)), + ffi.cast("GrB_Index*", ffi.from_buffer(cols)), + ffi.cast("GxB_FC64_t*", ffi.from_buffer(vals)), + nvals_p, + A[0], + ), + ) + return rows, cols, vals diff --git a/suitesparse_graphblas/api/monoid.py b/suitesparse_graphblas/api/monoid.py new file mode 100644 index 0000000..4706b05 --- /dev/null +++ b/suitesparse_graphblas/api/monoid.py @@ -0,0 +1,607 @@ +from suitesparse_graphblas import check_status, ffi, lib, supports_complex + +from .utils import _capture_c_output # noqa: F401 + + +def monoid_free(m): + """Free a monoid. + + >>> m = monoid_new_int64(lib.GrB_PLUS_INT64, 0) + >>> monoid_free(m) + + """ + check_status(m, lib.GrB_Monoid_free(m)) + + +# --------------------------------------------------------------------------- +# Typed constructors +# --------------------------------------------------------------------------- + + +def monoid_new_bool(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with a boolean identity. + + >>> m = monoid_new_bool(lib.GrB_LAND, True) + >>> monoid_operator(m) == lib.GrB_LAND + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_BOOL(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_int8(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an int8 identity. + + >>> m = monoid_new_int8(lib.GrB_PLUS_INT8, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT8 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_INT8(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_int16(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an int16 identity. + + >>> m = monoid_new_int16(lib.GrB_PLUS_INT16, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT16 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_INT16(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_int32(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an int32 identity. + + >>> m = monoid_new_int32(lib.GrB_PLUS_INT32, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_INT32(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_int64(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an int64 identity. + + >>> m = monoid_new_int64(lib.GrB_PLUS_INT64, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_INT64(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_uint8(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with a uint8 identity. + + >>> m = monoid_new_uint8(lib.GrB_PLUS_UINT8, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT8 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_UINT8(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_uint16(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with a uint16 identity. + + >>> m = monoid_new_uint16(lib.GrB_PLUS_UINT16, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT16 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_UINT16(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_uint32(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with a uint32 identity. + + >>> m = monoid_new_uint32(lib.GrB_PLUS_UINT32, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_UINT32(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_uint64(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with a uint64 identity. + + >>> m = monoid_new_uint64(lib.GrB_PLUS_UINT64, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_UINT64(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_fp32(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an fp32 identity. + + >>> m = monoid_new_fp32(lib.GrB_PLUS_FP32, 0.0) + >>> monoid_operator(m) == lib.GrB_PLUS_FP32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_FP32(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_fp64(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an fp64 identity. + + >>> m = monoid_new_fp64(lib.GrB_PLUS_FP64, 0.0) + >>> monoid_operator(m) == lib.GrB_PLUS_FP64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_FP64(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_new_udt(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with a user-defined type identity. + + The ``identity`` argument must be a ``void*`` pointer. + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GrB_Monoid_new_UDT(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + +# --------------------------------------------------------------------------- +# Terminal constructors +# --------------------------------------------------------------------------- + + +def monoid_terminal_new_bool(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with a boolean identity and terminal. + + >>> m = monoid_terminal_new_bool(lib.GrB_LAND, True, False) + >>> monoid_operator(m) == lib.GrB_LAND + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_BOOL(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_int8(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an int8 identity and terminal. + + >>> m = monoid_terminal_new_int8(lib.GrB_PLUS_INT8, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT8 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_INT8(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_int16(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an int16 identity and terminal. + + >>> m = monoid_terminal_new_int16(lib.GrB_PLUS_INT16, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT16 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_INT16(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_int32(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an int32 identity and terminal. + + >>> m = monoid_terminal_new_int32(lib.GrB_PLUS_INT32, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_INT32(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_int64(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an int64 identity and terminal. + + >>> m = monoid_terminal_new_int64(lib.GrB_PLUS_INT64, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_INT64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_INT64(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_uint8(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with a uint8 identity and terminal. + + >>> m = monoid_terminal_new_uint8(lib.GrB_PLUS_UINT8, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT8 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_UINT8(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_uint16(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with a uint16 identity and terminal. + + >>> m = monoid_terminal_new_uint16(lib.GrB_PLUS_UINT16, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT16 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_UINT16(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_uint32(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with a uint32 identity and terminal. + + >>> m = monoid_terminal_new_uint32(lib.GrB_PLUS_UINT32, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_UINT32(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_uint64(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with a uint64 identity and terminal. + + >>> m = monoid_terminal_new_uint64(lib.GrB_PLUS_UINT64, 0, 0) + >>> monoid_operator(m) == lib.GrB_PLUS_UINT64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_UINT64(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_fp32(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an fp32 identity and terminal. + + >>> m = monoid_terminal_new_fp32(lib.GrB_PLUS_FP32, 0.0, 0.0) + >>> monoid_operator(m) == lib.GrB_PLUS_FP32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_FP32(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_fp64(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an fp64 identity and terminal. + + >>> m = monoid_terminal_new_fp64(lib.GrB_PLUS_FP64, 0.0, 0.0) + >>> monoid_operator(m) == lib.GrB_PLUS_FP64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_FP64(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +def monoid_terminal_new_udt(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with a user-defined type identity and terminal. + + The ``identity`` and ``terminal`` arguments must be ``void*`` pointers. + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_UDT(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +if supports_complex(): + + def monoid_new_fc32(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an fc32 identity. + + >>> m = monoid_new_fc32(lib.GxB_PLUS_FC32, 0 + 0j) + >>> monoid_operator(m) == lib.GxB_PLUS_FC32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_new_FC32(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + def monoid_new_fc64(op, identity, *, free=monoid_free): + """Create a new GrB_Monoid with an fc64 identity. + + >>> m = monoid_new_fc64(lib.GxB_PLUS_FC64, 0 + 0j) + >>> monoid_operator(m) == lib.GxB_PLUS_FC64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_new_FC64(m, op, identity)) + if free: + return ffi.gc(m, free) + return m + + def monoid_terminal_new_fc32(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an fc32 identity and terminal. + + >>> m = monoid_terminal_new_fc32(lib.GxB_PLUS_FC32, 0 + 0j, 0 + 0j) + >>> monoid_operator(m) == lib.GxB_PLUS_FC32 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_FC32(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + def monoid_terminal_new_fc64(op, identity, terminal, *, free=monoid_free): + """Create a new GxB_Monoid with an fc64 identity and terminal. + + >>> m = monoid_terminal_new_fc64(lib.GxB_PLUS_FC64, 0 + 0j, 0 + 0j) + >>> monoid_operator(m) == lib.GxB_PLUS_FC64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(m, lib.GxB_Monoid_terminal_new_FC64(m, op, identity, terminal)) + if free: + return ffi.gc(m, free) + return m + + +# --------------------------------------------------------------------------- +# Wait +# --------------------------------------------------------------------------- + + +def monoid_wait(m, waitmode=lib.GrB_COMPLETE): + """Wait for a monoid to complete pending operations. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> monoid_wait(m) + + """ + check_status(m, lib.GrB_Monoid_wait(m[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def monoid_print(m, name="", level=lib.GxB_COMPLETE): + """Print a monoid to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> out = _capture_c_output(monoid_print, m, 'm', lib.GxB_SHORT) + >>> 'Monoid' in out + True + + """ + check_status( + m, + lib.GxB_Monoid_fprint( + m[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def monoid_fprint(m, f, name="", level=lib.GxB_COMPLETE): + """Print a monoid to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`monoid_print`). + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> out = _capture_c_output(monoid_fprint, m, ffi.NULL, 'm', lib.GxB_SHORT) + >>> 'Monoid' in out + True + + """ + check_status( + m, + lib.GxB_Monoid_fprint( + m[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def monoid_get_int32(m, field): + """Get a monoid option as an int32. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> monoid_get_int32(m, lib.GrB_INP0_TYPE_CODE) >= 0 + True + + """ + val = ffi.new("int32_t*") + check_status(m, lib.GrB_Monoid_get_INT32(m[0], val, field)) + return val[0] + + +def monoid_set_int32(m, field, value): + """Set a monoid option from an int32.""" + check_status(m, lib.GrB_Monoid_set_INT32(m[0], ffi.cast("int32_t", value), field)) + + +def monoid_get_size(m, field): + """Get a monoid option as a size_t. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> monoid_get_size(m, lib.GrB_NAME) >= 0 + True + + """ + val = ffi.new("size_t*") + check_status(m, lib.GrB_Monoid_get_SIZE(m[0], val, field)) + return val[0] + + +def monoid_get_string(m, field): + """Get a monoid option as a string. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> isinstance(monoid_get_string(m, lib.GrB_NAME), str) + True + + """ + val = ffi.new("char[256]") + check_status(m, lib.GrB_Monoid_get_String(m[0], val, field)) + return ffi.string(val).decode() + + +def monoid_set_string(m, field, value): + """Set a monoid option from a string.""" + check_status(m, lib.GrB_Monoid_set_String(m[0], value.encode(), field)) + + +# --------------------------------------------------------------------------- +# Accessors +# --------------------------------------------------------------------------- + + +def monoid_operator(m): + """Return the binary operator of a monoid. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> monoid_operator(m) == lib.GrB_PLUS_INT64 + True + + """ + op = ffi.new("GrB_BinaryOp*") + check_status(m, lib.GxB_Monoid_operator(op, m[0])) + return op[0] + + +def monoid_identity(m): + """Return a buffer containing the identity value of a monoid. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> val = monoid_identity(m) + + """ + val = ffi.new("char[256]") + check_status(m, lib.GxB_Monoid_identity(val, m[0])) + return val + + +def monoid_terminal(m): + """Return a (has_terminal, buffer) tuple for a monoid. + + ``has_terminal`` is a boolean indicating whether the monoid has a + terminal value. + + >>> m = ffi.new("GrB_Monoid*", lib.GrB_PLUS_MONOID_INT64) + >>> has_terminal, val = monoid_terminal(m) + >>> isinstance(has_terminal, bool) + True + + """ + has_terminal = ffi.new("bool*") + val = ffi.new("char[256]") + check_status(m, lib.GxB_Monoid_terminal(has_terminal, val, m[0])) + return has_terminal[0], val diff --git a/suitesparse_graphblas/api/scalar.py b/suitesparse_graphblas/api/scalar.py new file mode 100644 index 0000000..f4537a3 --- /dev/null +++ b/suitesparse_graphblas/api/scalar.py @@ -0,0 +1,504 @@ +"""Create, manipulate, and query GxB_Scalar objects.""" + +from suitesparse_graphblas import check_status, exceptions, ffi, lib, supports_complex + +from .utils import _capture_c_output # noqa: F401 + + +def scalar_free(v): + """Free a scalar.""" + check_status(v, lib.GxB_Scalar_free(v)) + + +def scalar_new(T, *, free=scalar_free): + """Create a new `GxB_Scalar` of type `T` and initialize it. + + The `free` argument is called when the object is garbage + collected, the default is `scalar.scalar_free()`. If `free` is None then + there is no automatic garbage collection and it is up to the user + to free the scalar. + + >>> S = scalar_new(lib.GrB_UINT8) + + """ + s = ffi.new("GxB_Scalar*") + check_status(s, lib.GxB_Scalar_new(s, T)) + if free: + return ffi.gc(s, free) + return s + + +def scalar_type(s): + """Return the GraphBLAS type of the scalar. + + >>> S = scalar_new(lib.GrB_UINT8) + >>> scalar_type(S) == lib.GrB_UINT8 + True + + """ + T = ffi.new("GrB_Type*") + check_status(s, lib.GxB_Scalar_type(T, s[0])) + return T[0] + + +# --------------------------------------------------------------------------- +# GraphBLAS operations +# --------------------------------------------------------------------------- + + +def scalar_dup(s, *, free=scalar_free): + """Duplicate a scalar. + + >>> s = scalar_new(lib.GrB_INT64) + >>> set_int64(s, 42) + >>> t = scalar_dup(s) + >>> get_int64(t) == 42 + True + + """ + t = ffi.new("GxB_Scalar*") + check_status(t, lib.GrB_Scalar_dup(t, s[0])) + if free: + return ffi.gc(t, free) + return t + + +def scalar_clear(s): + """Remove the entry from a scalar. + + >>> s = scalar_new(lib.GrB_INT64) + >>> set_int64(s, 42) + >>> get_int64(s) == 42 + True + >>> scalar_clear(s) + >>> get_int64(s) is None + True + + """ + check_status(s, lib.GrB_Scalar_clear(s[0])) + + +def scalar_wait(s, waitmode=lib.GrB_COMPLETE): + """Wait for a scalar to complete pending operations. + + >>> s = scalar_new(lib.GrB_INT64) + >>> scalar_wait(s) + + """ + check_status(s, lib.GrB_Scalar_wait(s[0], waitmode)) + + +def scalar_print(s, name="", level=lib.GxB_COMPLETE): + """Print a scalar to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> s = scalar_new(lib.GrB_INT64) + >>> set_int64(s, 42) + >>> out = _capture_c_output(scalar_print, s, 's', lib.GxB_SHORT) + >>> 'int64_t scalar' in out + True + >>> '(0,0) 42' in out + True + + """ + check_status( + s, + lib.GxB_Scalar_fprint( + s[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def scalar_fprint(s, f, name="", level=lib.GxB_COMPLETE): + """Print a scalar to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`scalar_print`). + + >>> s = scalar_new(lib.GrB_INT64) + >>> set_int64(s, 7) + >>> out = _capture_c_output(scalar_fprint, s, ffi.NULL, 's', lib.GxB_SHORT) + >>> 'int64_t scalar' in out + True + >>> '(0,0) 7' in out + True + + """ + check_status( + s, + lib.GxB_Scalar_fprint( + s[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +def set_bool(s, value): + """Set a boolean value to the scalar. + + >>> s = scalar_new(lib.GrB_BOOL) + >>> set_bool(s, True) + >>> get_bool(s) == True + True + + """ + check_status(s, lib.GxB_Scalar_setElement_BOOL(s[0], value)) + + +def get_bool(s): + """Get a boolean value from the scalar. + + >>> s = scalar_new(lib.GrB_BOOL) + >>> set_bool(s, True) + >>> get_bool(s) == True + True + + """ + value = ffi.new("bool*") + res = check_status(s, lib.GxB_Scalar_extractElement_BOOL(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_int8(s, value): + """Set an int8 value to the scalar. + + >>> s = scalar_new(lib.GrB_INT8) + >>> set_int8(s, 7) + >>> get_int8(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_INT8(s[0], value)) + + +def get_int8(s): + """Get an int8 value from the scalar. + + >>> s = scalar_new(lib.GrB_INT8) + >>> set_int8(s, 7) + >>> get_int8(s) == 7 + True + + """ + value = ffi.new("int8_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_INT8(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_int16(s, value): + """Set an int16 value to the scalar. + + >>> s = scalar_new(lib.GrB_INT16) + >>> set_int16(s, 7) + >>> get_int16(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_INT16(s[0], value)) + + +def get_int16(s): + """Get an int16 value from the scalar. + + >>> s = scalar_new(lib.GrB_INT16) + >>> set_int16(s, 7) + >>> get_int16(s) == 7 + True + + """ + value = ffi.new("int16_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_INT16(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_int32(s, value): + """Set an int32 value to the scalar. + + >>> s = scalar_new(lib.GrB_INT32) + >>> set_int32(s, 7) + >>> get_int32(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_INT32(s[0], value)) + + +def get_int32(s): + """Get an int32 value from the scalar. + + >>> s = scalar_new(lib.GrB_INT32) + >>> set_int32(s, 7) + >>> get_int32(s) == 7 + True + + """ + value = ffi.new("int32_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_INT32(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_int64(s, value): + """Set an int64 value to the scalar. + + >>> s = scalar_new(lib.GrB_INT64) + >>> set_int64(s, 7) + >>> get_int64(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_INT64(s[0], value)) + + +def get_int64(s): + """Get an int64 value from the scalar. + + >>> s = scalar_new(lib.GrB_INT64) + >>> set_int64(s, 7) + >>> get_int64(s) == 7 + True + + """ + value = ffi.new("int64_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_INT64(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_uint8(s, value): + """Set a uint8 value to the scalar. + + >>> s = scalar_new(lib.GrB_UINT8) + >>> set_uint8(s, 7) + >>> get_uint8(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_UINT8(s[0], value)) + + +def get_uint8(s): + """Get a uint8 value from the scalar. + + >>> s = scalar_new(lib.GrB_UINT8) + >>> set_uint8(s, 7) + >>> get_uint8(s) == 7 + True + + """ + value = ffi.new("uint8_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_UINT8(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_uint16(s, value): + """Set a uint16 value to the scalar. + + >>> s = scalar_new(lib.GrB_UINT16) + >>> set_uint16(s, 7) + >>> get_uint16(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_UINT16(s[0], value)) + + +def get_uint16(s): + """Get a uint16 value from the scalar. + + >>> s = scalar_new(lib.GrB_UINT16) + >>> set_uint16(s, 7) + >>> get_uint16(s) == 7 + True + + """ + value = ffi.new("uint16_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_UINT16(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_uint32(s, value): + """Set a uint32 value to the scalar. + + >>> s = scalar_new(lib.GrB_UINT32) + >>> set_uint32(s, 7) + >>> get_uint32(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_UINT32(s[0], value)) + + +def get_uint32(s): + """Get a uint32 value from the scalar. + + >>> s = scalar_new(lib.GrB_UINT32) + >>> set_uint32(s, 7) + >>> get_uint32(s) == 7 + True + + """ + value = ffi.new("uint32_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_UINT32(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_uint64(s, value): + """Set a uint64 value to the scalar. + + >>> s = scalar_new(lib.GrB_UINT64) + >>> set_uint64(s, 7) + >>> get_uint64(s) == 7 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_UINT64(s[0], value)) + + +def get_uint64(s): + """Get a uint64 value from the scalar. + + >>> s = scalar_new(lib.GrB_UINT64) + >>> set_uint64(s, 7) + >>> get_uint64(s) == 7 + True + + """ + value = ffi.new("uint64_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_UINT64(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_fp32(s, value): + """Set an fp32 value to the scalar. + + >>> s = scalar_new(lib.GrB_FP32) + >>> set_fp32(s, 1.5) + >>> get_fp32(s) == 1.5 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_FP32(s[0], value)) + + +def get_fp32(s): + """Get an fp32 value from the scalar. + + >>> s = scalar_new(lib.GrB_FP32) + >>> set_fp32(s, 1.5) + >>> get_fp32(s) == 1.5 + True + + """ + value = ffi.new("float*") + res = check_status(s, lib.GxB_Scalar_extractElement_FP32(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +def set_fp64(s, value): + """Set an fp64 value to the scalar. + + >>> s = scalar_new(lib.GrB_FP64) + >>> set_fp64(s, 1.5) + >>> get_fp64(s) == 1.5 + True + + """ + check_status(s, lib.GxB_Scalar_setElement_FP64(s[0], value)) + + +def get_fp64(s): + """Get an fp64 value from the scalar. + + >>> s = scalar_new(lib.GrB_FP64) + >>> set_fp64(s, 1.5) + >>> get_fp64(s) == 1.5 + True + + """ + value = ffi.new("double*") + res = check_status(s, lib.GxB_Scalar_extractElement_FP64(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + +if supports_complex(): + + def set_fc32(s, value): + """Set an fc32 value to the scalar. + + >>> s = scalar_new(lib.GxB_FC32) + >>> set_fc32(s, 2+3j) + >>> get_fc32(s) == 2+3j + True + + """ + check_status(s, lib.GxB_Scalar_setElement_FC32(s[0], value)) + + def get_fc32(s): + """Get an fc32 value from the scalar. + + >>> s = scalar_new(lib.GxB_FC32) + >>> set_fc32(s, 2+3j) + >>> get_fc32(s) == 2+3j + True + + """ + value = ffi.new("GxB_FC32_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_FC32(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] + + def set_fc64(s, value): + """Set an fc64 value to the scalar. + + >>> s = scalar_new(lib.GxB_FC64) + >>> set_fc64(s, 2+3j) + >>> get_fc64(s) == 2+3j + True + + """ + check_status(s, lib.GxB_Scalar_setElement_FC64(s[0], value)) + + def get_fc64(s): + """Get an fc64 value from the scalar. + + >>> s = scalar_new(lib.GxB_FC64) + >>> set_fc64(s, 2+3j) + >>> get_fc64(s) == 2+3j + True + + """ + value = ffi.new("GxB_FC64_t*") + res = check_status(s, lib.GxB_Scalar_extractElement_FC64(value, s[0])) + if res == exceptions.NoValue: + return None + return value[0] diff --git a/suitesparse_graphblas/api/selectop.py b/suitesparse_graphblas/api/selectop.py new file mode 100644 index 0000000..f80aa75 --- /dev/null +++ b/suitesparse_graphblas/api/selectop.py @@ -0,0 +1,86 @@ +from suitesparse_graphblas import _error_code_lookup, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def selectop_xtype(op): + """Return the xtype of a select operator. + + >>> op = ffi.new("GxB_SelectOp*", lib.GxB_TRIL) + >>> selectop_xtype(op) == ffi.NULL + True + + """ + T = ffi.new("GrB_Type*") + info = lib.GxB_SelectOp_xtype(T, op[0]) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_SelectOp_xtype failed with info={info}" + ) + return T[0] + + +def selectop_ttype(op): + """Return the ttype (thunk type) of a select operator. + + >>> op = ffi.new("GxB_SelectOp*", lib.GxB_TRIL) + >>> selectop_ttype(op) == ffi.NULL + True + + """ + T = ffi.new("GrB_Type*") + info = lib.GxB_SelectOp_ttype(T, op[0]) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_SelectOp_ttype failed with info={info}" + ) + return T[0] + + +def selectop_print(op, name="", level=lib.GxB_COMPLETE): + """Print a select operator to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> op = ffi.new("GxB_SelectOp*", lib.GxB_TRIL) + >>> out = _capture_c_output(selectop_print, op, 'op', lib.GxB_SHORT) + >>> 'tril' in out.lower() + True + + """ + info = lib.GxB_SelectOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_SelectOp_fprint failed with info={info}" + ) + + +def selectop_fprint(op, f, name="", level=lib.GxB_COMPLETE): + """Print a select operator to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`selectop_print`). + + >>> op = ffi.new("GxB_SelectOp*", lib.GxB_TRIL) + >>> out = _capture_c_output(selectop_fprint, op, ffi.NULL, 'op', lib.GxB_SHORT) + >>> 'tril' in out.lower() + True + + """ + info = lib.GxB_SelectOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ) + if info != lib.GrB_SUCCESS: + raise _error_code_lookup.get(info, RuntimeError)( + f"GxB_SelectOp_fprint failed with info={info}" + ) diff --git a/suitesparse_graphblas/api/semiring.py b/suitesparse_graphblas/api/semiring.py new file mode 100644 index 0000000..e942c3c --- /dev/null +++ b/suitesparse_graphblas/api/semiring.py @@ -0,0 +1,188 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def semiring_free(s): + """Free a semiring. + + >>> s = semiring_new(lib.GrB_PLUS_MONOID_INT64, lib.GrB_TIMES_INT64) + >>> semiring_free(s) + + """ + check_status(s, lib.GrB_Semiring_free(s)) + + +def semiring_new(add, multiply, *, free=semiring_free): + """Create a new GrB_Semiring from a monoid and binary operator. + + ``add`` is a ``GrB_Monoid`` value and ``multiply`` is a + ``GrB_BinaryOp`` value. + + The ``free`` argument is called when the object is garbage + collected, the default is ``semiring.semiring_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the semiring. + + >>> s = semiring_new(lib.GrB_PLUS_MONOID_INT64, lib.GrB_TIMES_INT64) + >>> semiring_multiply(s) == lib.GrB_TIMES_INT64 + True + + """ + s = ffi.new("GrB_Semiring*") + check_status(s, lib.GrB_Semiring_new(s, add, multiply)) + if free: + return ffi.gc(s, free) + return s + + +# --------------------------------------------------------------------------- +# Wait +# --------------------------------------------------------------------------- + + +def semiring_wait(s, waitmode=lib.GrB_COMPLETE): + """Wait for a semiring to complete pending operations. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> semiring_wait(s) + + """ + check_status(s, lib.GrB_Semiring_wait(s[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def semiring_print(s, name="", level=lib.GxB_COMPLETE): + """Print a semiring to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> out = _capture_c_output(semiring_print, s, 's', lib.GxB_SHORT) + >>> 'Semiring' in out + True + + """ + check_status( + s, + lib.GxB_Semiring_fprint( + s[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def semiring_fprint(s, f, name="", level=lib.GxB_COMPLETE): + """Print a semiring to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`semiring_print`). + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> out = _capture_c_output(semiring_fprint, s, ffi.NULL, 's', lib.GxB_SHORT) + >>> 'Semiring' in out + True + + """ + check_status( + s, + lib.GxB_Semiring_fprint( + s[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def semiring_get_int32(s, field): + """Get a semiring option as an int32. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> semiring_get_int32(s, lib.GrB_INP0_TYPE_CODE) >= 0 + True + + """ + val = ffi.new("int32_t*") + check_status(s, lib.GrB_Semiring_get_INT32(s[0], val, field)) + return val[0] + + +def semiring_set_int32(s, field, value): + """Set a semiring option from an int32.""" + check_status(s, lib.GrB_Semiring_set_INT32(s[0], ffi.cast("int32_t", value), field)) + + +def semiring_get_size(s, field): + """Get a semiring option as a size_t. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> semiring_get_size(s, lib.GrB_NAME) >= 0 + True + + """ + val = ffi.new("size_t*") + check_status(s, lib.GrB_Semiring_get_SIZE(s[0], val, field)) + return val[0] + + +def semiring_get_string(s, field): + """Get a semiring option as a string. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> isinstance(semiring_get_string(s, lib.GrB_NAME), str) + True + + """ + val = ffi.new("char[256]") + check_status(s, lib.GrB_Semiring_get_String(s[0], val, field)) + return ffi.string(val).decode() + + +def semiring_set_string(s, field, value): + """Set a semiring option from a string.""" + check_status(s, lib.GrB_Semiring_set_String(s[0], value.encode(), field)) + + +# --------------------------------------------------------------------------- +# Accessors +# --------------------------------------------------------------------------- + + +def semiring_add(s): + """Return the additive monoid of a semiring. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> semiring_add(s) == lib.GrB_PLUS_MONOID_INT64 + True + + """ + m = ffi.new("GrB_Monoid*") + check_status(s, lib.GxB_Semiring_add(m, s[0])) + return m[0] + + +def semiring_multiply(s): + """Return the multiply binary operator of a semiring. + + >>> s = ffi.new("GrB_Semiring*", lib.GrB_PLUS_TIMES_SEMIRING_INT64) + >>> semiring_multiply(s) == lib.GrB_TIMES_INT64 + True + + """ + op = ffi.new("GrB_BinaryOp*") + check_status(s, lib.GxB_Semiring_multiply(op, s[0])) + return op[0] diff --git a/suitesparse_graphblas/api/unaryop.py b/suitesparse_graphblas/api/unaryop.py new file mode 100644 index 0000000..f5f4fc3 --- /dev/null +++ b/suitesparse_graphblas/api/unaryop.py @@ -0,0 +1,238 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .utils import _capture_c_output # noqa: F401 + + +def unaryop_free(op): + """Free a unary operator. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_free(op) + + """ + check_status(op, lib.GrB_UnaryOp_free(op)) + + +def unaryop_new(function, ztype, xtype, *, free=unaryop_free): + """Create a new GrB_UnaryOp from a C function pointer. + + ``function`` must be a CFFI callback compatible with + ``GxB_unary_function``. + + The ``free`` argument is called when the object is garbage + collected, the default is ``unaryop.unaryop_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the operator. + """ + op = ffi.new("GrB_UnaryOp*") + check_status(op, lib.GrB_UnaryOp_new(op, function, ztype, xtype)) + if free: + return ffi.gc(op, free) + return op + + +def unaryop_new_named(function, ztype, xtype, name, defn, *, free=unaryop_free): + """Create a new named GrB_UnaryOp (GxB extension). + + ``function`` must be a CFFI callback compatible with + ``GxB_unary_function``. ``name`` and ``defn`` are C strings + describing the operator for JIT compilation. + + The ``free`` argument is called when the object is garbage + collected, the default is ``unaryop.unaryop_free()``. If ``free`` + is None then there is no automatic garbage collection and it is up + to the user to free the operator. + """ + op = ffi.new("GrB_UnaryOp*") + check_status( + op, + lib.GxB_UnaryOp_new( + op, + function, + ztype, + xtype, + name.encode() if isinstance(name, str) else name, + defn.encode() if isinstance(defn, str) else defn, + ), + ) + if free: + return ffi.gc(op, free) + return op + + +def unaryop_wait(op, waitmode=lib.GrB_COMPLETE): + """Wait for a unary operator to complete pending operations. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_wait(op) + + """ + check_status(op, lib.GrB_UnaryOp_wait(op[0], waitmode)) + + +# --------------------------------------------------------------------------- +# Print +# --------------------------------------------------------------------------- + + +def unaryop_print(op, name="", level=lib.GxB_COMPLETE): + """Print a unary operator to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> out = _capture_c_output(unaryop_print, op, 'op', lib.GxB_SHORT) + >>> 'ainv' in out.lower() + True + + """ + check_status( + op, + lib.GxB_UnaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def unaryop_fprint(op, f, name="", level=lib.GxB_COMPLETE): + """Print a unary operator to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`unaryop_print`). + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> out = _capture_c_output(unaryop_fprint, op, ffi.NULL, 'op', lib.GxB_SHORT) + >>> 'ainv' in out.lower() + True + + """ + check_status( + op, + lib.GxB_UnaryOp_fprint( + op[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +# --------------------------------------------------------------------------- +# Option get/set (typed) +# --------------------------------------------------------------------------- + + +def unaryop_get_int32(op, field): + """Get an operator option as an int32. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_get_int32(op, lib.GrB_OUTP_TYPE_CODE) >= 0 + True + + """ + val = ffi.new("int32_t*") + check_status(op, lib.GrB_UnaryOp_get_INT32(op[0], val, field)) + return val[0] + + +def unaryop_set_int32(op, field, value): + """Set an operator option from an int32.""" + check_status(op, lib.GrB_UnaryOp_set_INT32(op[0], ffi.cast("int32_t", value), field)) + + +def unaryop_get_size(op, field): + """Get an operator option as a size_t. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_get_size(op, lib.GrB_NAME) > 0 + True + + """ + val = ffi.new("size_t*") + check_status(op, lib.GrB_UnaryOp_get_SIZE(op[0], val, field)) + return val[0] + + +def unaryop_get_string(op, field): + """Get an operator option as a string. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> 'ainv' in unaryop_get_string(op, lib.GrB_NAME).lower() + True + + """ + val = ffi.new("char[256]") + check_status(op, lib.GrB_UnaryOp_get_String(op[0], val, field)) + return ffi.string(val).decode() + + +def unaryop_set_string(op, field, value): + """Set an operator option from a string.""" + check_status( + op, + lib.GrB_UnaryOp_set_String( + op[0], value.encode() if isinstance(value, str) else value, field + ), + ) + + +# --------------------------------------------------------------------------- +# Type queries +# --------------------------------------------------------------------------- + + +def unaryop_xtype(op): + """Return the input (x) type of a unary operator. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_xtype(op) == lib.GrB_INT64 + True + + """ + T = ffi.new("GrB_Type*") + check_status(op, lib.GxB_UnaryOp_xtype(T, op[0])) + return T[0] + + +def unaryop_ztype(op): + """Return the output (z) type of a unary operator. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_ztype(op) == lib.GrB_INT64 + True + + """ + T = ffi.new("GrB_Type*") + check_status(op, lib.GxB_UnaryOp_ztype(T, op[0])) + return T[0] + + +def unaryop_xtype_name(op): + """Return the input (x) type name of a unary operator as a string. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_xtype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_UnaryOp_xtype_name(name, op[0])) + return ffi.string(name).decode() + + +def unaryop_ztype_name(op): + """Return the output (z) type name of a unary operator as a string. + + >>> op = ffi.new("GrB_UnaryOp*", lib.GrB_AINV_INT64) + >>> unaryop_ztype_name(op) + 'int64_t' + + """ + name = ffi.new("char[256]") + check_status(op, lib.GxB_UnaryOp_ztype_name(name, op[0])) + return ffi.string(name).decode() diff --git a/suitesparse_graphblas/api/utils.py b/suitesparse_graphblas/api/utils.py new file mode 100644 index 0000000..df5d3eb --- /dev/null +++ b/suitesparse_graphblas/api/utils.py @@ -0,0 +1,16 @@ +import os +import sys + + +def _capture_c_output(fn, *args): + """Capture C-level stdout output from a function call.""" + sys.stdout.flush() + r, w = os.pipe() + old = os.dup(1) + os.dup2(w, 1) + fn(*args) + os.dup2(old, 1) + os.close(w) + out = os.read(r, 100000).decode() + os.close(r) + return out diff --git a/suitesparse_graphblas/api/vector.py b/suitesparse_graphblas/api/vector.py new file mode 100644 index 0000000..f123028 --- /dev/null +++ b/suitesparse_graphblas/api/vector.py @@ -0,0 +1,1715 @@ +"""Create, manipulate, and query GrB_Vector objects.""" + +import numpy as np + +from suitesparse_graphblas import check_status, ffi, lib, supports_complex + +from .io.serialize import deserialize_vector as deserialize # noqa: F401 +from .io.serialize import serialize_vector as serialize # noqa: F401 +from .utils import _capture_c_output # noqa: F401 + + +def vector_free(v): + """Free a vector.""" + check_status(v, lib.GrB_Vector_free(v)) + + +def vector_new(T, size=lib.GxB_INDEX_MAX, *, free=vector_free): + """Create a new `GrB_Vector` of type `T` and initialize it. + + >>> A = vector_new(lib.GrB_UINT8, 2) + >>> vector_size(A) + 2 + + The default `size` is `lib.GxB_INDEX_MAX`. + + >>> A = vector_new(lib.GrB_UINT8) + >>> vector_size(A) == lib.GxB_INDEX_MAX + True + + The `free` argument is called when the object is garbage + collected, the default is `vector.vector_free()`. If `free` is None then + there is no automatic garbage collection and it is up to the user + to free the vector. + """ + v = ffi.new("GrB_Vector*") + check_status(v, lib.GrB_Vector_new(v, T, size)) + if free: + return ffi.gc(v, free) + return v + + +def vector_type(v): + """Return the GraphBLAS type of the vector. + + >>> v = vector_new(lib.GrB_UINT8, 2) + >>> vector_type(v) == lib.GrB_UINT8 + True + + + """ + T = ffi.new("GrB_Type*") + check_status(v, lib.GxB_Vector_type(T, v[0])) + return T[0] + + +def vector_size(v): + """Return the size of the vector. + + >>> v = vector_new(lib.GrB_UINT8, 2) + >>> vector_size(v) == 2 + True + + """ + n = ffi.new("GrB_Index*") + check_status(v, lib.GrB_Vector_size(n, v[0])) + return n[0] + + +def vector_nvals(v): + """Return the number of stored elements in the vector. + + >>> v = vector_new(lib.GrB_BOOL, 2) + >>> vector_nvals(v) + 0 + >>> set_bool(v, True, 1) + >>> vector_nvals(v) + 1 + + """ + n = ffi.new("GrB_Index*") + check_status(v, lib.GrB_Vector_nvals(n, v[0])) + return n[0] + + +def vector_option_get_int32(v, field): + """Get a vector option as an int32. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> vector_option_get_int32(v, lib.GxB_SPARSITY_STATUS) in (1, 2, 4, 8) + True + + """ + val = ffi.new("int32_t*") + check_status(v, lib.GxB_Vector_Option_get_INT32(v[0], field, val)) + return val[0] + + +def vector_option_set_int32(v, field, value): + """Set a vector option from an int32. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> vector_option_set_int32(v, lib.GxB_SPARSITY_CONTROL, lib.GxB_SPARSE) + >>> vector_option_get_int32(v, lib.GxB_SPARSITY_CONTROL) == lib.GxB_SPARSE + True + + """ + check_status( + v, + lib.GxB_Vector_Option_set_INT32( + v[0], + field, + ffi.cast("int32_t", value), + ), + ) + + +def vector_option_get_fp64(v, field): + """Get a vector option as a float64. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> isinstance(vector_option_get_fp64(v, lib.GxB_BITMAP_SWITCH), float) + True + + """ + val = ffi.new("double*") + check_status(v, lib.GxB_Vector_Option_get_FP64(v[0], field, val)) + return val[0] + + +def vector_option_set_fp64(v, field, value): + """Set a vector option from a float64. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> vector_option_set_fp64(v, lib.GxB_BITMAP_SWITCH, 0.25) + >>> vector_option_get_fp64(v, lib.GxB_BITMAP_SWITCH) == 0.25 + True + + """ + check_status( + v, + lib.GxB_Vector_Option_set_FP64( + v[0], + field, + ffi.cast("double", value), + ), + ) + + +# --------------------------------------------------------------------------- +# GraphBLAS operations +# --------------------------------------------------------------------------- + + +def vector_dup(v, *, free=vector_free): + """Duplicate a vector. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 42, 0) + >>> w = vector_dup(v) + >>> get_int64(w, 0) == 42 + True + + """ + w = ffi.new("GrB_Vector*") + check_status(w, lib.GrB_Vector_dup(w, v[0])) + if free: + return ffi.gc(w, free) + return w + + +def vector_clear(v): + """Remove all entries from a vector. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 42, 0) + >>> vector_nvals(v) == 1 + True + >>> vector_clear(v) + >>> vector_nvals(v) == 0 + True + + """ + check_status(v, lib.GrB_Vector_clear(v[0])) + + +def vector_wait(v, waitmode=lib.GrB_COMPLETE): + """Wait for a vector to complete pending operations. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> vector_wait(v) + + """ + check_status(v, lib.GrB_Vector_wait(v[0], waitmode)) + + +def vector_print(v, name="", level=lib.GxB_COMPLETE): + """Print a vector to stdout. + + ``level`` controls verbosity: ``lib.GxB_SILENT``, ``lib.GxB_SUMMARY``, + ``lib.GxB_SHORT``, ``lib.GxB_COMPLETE``, ``lib.GxB_SHORT_VERBOSE``, + or ``lib.GxB_COMPLETE_VERBOSE``. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 42, 0) + >>> vector_wait(v, lib.GrB_MATERIALIZE) + >>> out = _capture_c_output(vector_print, v, 'v', lib.GxB_SHORT) + >>> 'int64_t vector' in out + True + >>> '(0,0) 42' in out + True + + """ + check_status( + v, + lib.GxB_Vector_fprint( + v[0], + name.encode() if isinstance(name, str) else name, + level, + ffi.NULL, + ), + ) + + +def vector_fprint(v, f, name="", level=lib.GxB_COMPLETE): + """Print a vector to a C FILE* stream. + + Pass ``ffi.NULL`` for ``f`` to print to stdout. + ``level`` controls verbosity (see :func:`vector_print`). + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 7, 2) + >>> vector_wait(v, lib.GrB_MATERIALIZE) + >>> out = _capture_c_output(vector_fprint, v, ffi.NULL, 'v', lib.GxB_SHORT) + >>> 'int64_t vector' in out + True + >>> '(2,0) 7' in out + True + + """ + check_status( + v, + lib.GxB_Vector_fprint( + v[0], + name.encode() if isinstance(name, str) else name, + level, + f, + ), + ) + + +def vector_mxv(w, semiring, A, u, mask=None, accum=None, desc=None): + """Matrix-vector multiply: w = A (+.*) u. + + >>> from suitesparse_graphblas import matrix + >>> w = vector_new(lib.GrB_INT64, 2) + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> u = vector_new(lib.GrB_INT64, 2) + >>> matrix.set_int64(A, 3, 0, 0) + >>> set_int64(u, 2, 0) + >>> vector_mxv(w, lib.GrB_PLUS_TIMES_SEMIRING_INT64, A, u) + >>> get_int64(w, 0) == 6 + True + + """ + check_status( + w, + lib.GrB_mxv( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + semiring, + A[0], + u[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_vxm(w, semiring, u, A, mask=None, accum=None, desc=None): + """Vector-matrix multiply: w = u (+.*) A. + + >>> from suitesparse_graphblas import matrix + >>> w = vector_new(lib.GrB_INT64, 2) + >>> u = vector_new(lib.GrB_INT64, 2) + >>> A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + >>> set_int64(u, 2, 0) + >>> matrix.set_int64(A, 3, 0, 0) + >>> vector_vxm(w, lib.GrB_PLUS_TIMES_SEMIRING_INT64, u, A) + >>> get_int64(w, 0) == 6 + True + + """ + check_status( + w, + lib.GrB_vxm( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + semiring, + u[0], + A[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_ewise_add(w, op, u, v, mask=None, accum=None, desc=None): + """Element-wise addition of two vectors using a binary operator. + + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 2, 0) + >>> set_int64(v, 3, 0) + >>> vector_ewise_add(w, lib.GrB_PLUS_INT64, u, v) + >>> get_int64(w, 0) == 5 + True + + """ + check_status( + w, + lib.GrB_Vector_eWiseAdd_BinaryOp( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + v[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_ewise_mult(w, op, u, v, mask=None, accum=None, desc=None): + """Element-wise multiplication of two vectors using a binary operator. + + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 2, 0) + >>> set_int64(v, 3, 0) + >>> vector_ewise_mult(w, lib.GrB_TIMES_INT64, u, v) + >>> get_int64(w, 0) == 6 + True + + """ + check_status( + w, + lib.GrB_Vector_eWiseMult_BinaryOp( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + v[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_ewise_union(w, op, u, alpha, v, beta, mask=None, accum=None, desc=None): + """Element-wise union of two vectors using a binary operator. + + Unlike eWiseAdd, entries present in only one operand use the + corresponding default scalar (``alpha`` for u, ``beta`` for v). + + >>> from suitesparse_graphblas import scalar + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 2, 0) + >>> set_int64(v, 3, 2) + >>> a = scalar.scalar_new(lib.GrB_INT64) + >>> b = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(a, 0) + >>> scalar.set_int64(b, 0) + >>> vector_ewise_union(w, lib.GrB_PLUS_INT64, u, a, v, b) + >>> get_int64(w, 0) == 2 + True + >>> get_int64(w, 2) == 3 + True + + """ + check_status( + w, + lib.GxB_Vector_eWiseUnion( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + alpha[0], + v[0], + beta[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_apply(w, op, u, mask=None, accum=None, desc=None): + """Apply a unary operator to each entry of a vector. + + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, -5, 0) + >>> vector_apply(w, lib.GrB_ABS_INT64, u) + >>> get_int64(w, 0) == 5 + True + + """ + check_status( + w, + lib.GrB_Vector_apply( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_apply_first(w, op, x, u, mask=None, accum=None, desc=None): + """Apply a binary operator with a scalar bound to the first argument: w = op(x, u). + + >>> from suitesparse_graphblas import scalar + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 3, 0) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 10) + >>> vector_apply_first(w, lib.GrB_TIMES_INT64, s, u) + >>> get_int64(w, 0) == 30 + True + + """ + check_status( + w, + lib.GrB_Vector_apply_BinaryOp1st_Scalar( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + x[0], + u[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_apply_second(w, op, u, y, mask=None, accum=None, desc=None): + """Apply a binary operator with a scalar bound to the second argument: w = op(u, y). + + >>> from suitesparse_graphblas import scalar + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 10, 0) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 3) + >>> vector_apply_second(w, lib.GrB_TIMES_INT64, u, s) + >>> get_int64(w, 0) == 30 + True + + """ + check_status( + w, + lib.GrB_Vector_apply_BinaryOp2nd_Scalar( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + y[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_apply_indexop(w, op, u, thunk, mask=None, accum=None, desc=None): + """Apply an index unary operator to each entry of a vector with a scalar thunk. + + >>> from suitesparse_graphblas import scalar + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 10, 0) + >>> set_int64(u, 20, 2) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 0) + >>> vector_apply_indexop(w, lib.GrB_ROWINDEX_INT64, u, s) + >>> get_int64(w, 0) == 0 + True + >>> get_int64(w, 2) == 2 + True + + """ + check_status( + w, + lib.GrB_Vector_apply_IndexOp_Scalar( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + thunk[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_select(w, op, u, thunk, mask=None, accum=None, desc=None): + """Select entries from a vector using an index unary operator and scalar thunk. + + >>> from suitesparse_graphblas import scalar + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 5, 0) + >>> set_int64(u, 1, 1) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 3) + >>> vector_select(w, lib.GrB_VALUEGT_INT64, u, s) + >>> vector_nvals(w) == 1 + True + >>> get_int64(w, 0) == 5 + True + + """ + check_status( + w, + lib.GrB_Vector_select_Scalar( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + op, + u[0], + thunk[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_reduce(s, monoid, u, accum=None, desc=None): + """Reduce a vector to a scalar using a monoid. + + >>> from suitesparse_graphblas import scalar + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 2, 0) + >>> set_int64(u, 3, 1) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> vector_reduce(s, lib.GrB_PLUS_MONOID_INT64, u) + >>> scalar.get_int64(s) == 5 + True + + """ + check_status( + s, + lib.GrB_Vector_reduce_Monoid_Scalar( + s[0], + ffi.NULL if accum is None else accum, + monoid, + u[0], + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_diag(v, A, k=0, desc=None): + """Extract the k-th diagonal of a matrix into a vector. + + ``k=0`` is the main diagonal, positive is above, negative below. + + >>> from suitesparse_graphblas import matrix + >>> A = matrix.matrix_new(lib.GrB_INT64, 3, 3) + >>> matrix.set_int64(A, 10, 0, 0) + >>> matrix.set_int64(A, 20, 1, 1) + >>> matrix.set_int64(A, 30, 2, 2) + >>> v = vector_new(lib.GrB_INT64, 3) + >>> vector_diag(v, A, 0) + >>> get_int64(v, 0) == 10 + True + >>> get_int64(v, 1) == 20 + True + >>> get_int64(v, 2) == 30 + True + + """ + check_status( + v, + lib.GxB_Vector_diag( + v[0], + A[0], + k, + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_assign(w, u, indices, ni, mask=None, accum=None, desc=None): + """Assign a subvector: w[indices] = u. + + >>> w = vector_new(lib.GrB_INT64, 3) + >>> u = vector_new(lib.GrB_INT64, 1) + >>> set_int64(u, 42, 0) + >>> idx = ffi.new("GrB_Index[1]", [1]) + >>> vector_assign(w, u, idx, 1) + >>> get_int64(w, 1) == 42 + True + + """ + check_status( + w, + lib.GrB_Vector_assign( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + u[0], + indices, + ni, + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_assign_scalar(w, x, indices, ni, mask=None, accum=None, desc=None): + """Assign a scalar to subvector positions: w[indices] = x. + + >>> from suitesparse_graphblas import scalar + >>> w = vector_new(lib.GrB_INT64, 3) + >>> s = scalar.scalar_new(lib.GrB_INT64) + >>> scalar.set_int64(s, 99) + >>> idx = ffi.new("GrB_Index[2]", [0, 2]) + >>> vector_assign_scalar(w, s, idx, 2) + >>> get_int64(w, 0) == 99 + True + >>> get_int64(w, 2) == 99 + True + + """ + check_status( + w, + lib.GrB_Vector_assign_Scalar( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + x[0], + indices, + ni, + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_extract(w, u, indices, ni, mask=None, accum=None, desc=None): + """Extract a subvector: w = u[indices]. + + >>> u = vector_new(lib.GrB_INT64, 3) + >>> set_int64(u, 42, 2) + >>> w = vector_new(lib.GrB_INT64, 1) + >>> idx = ffi.new("GrB_Index[1]", [2]) + >>> vector_extract(w, u, idx, 1) + >>> get_int64(w, 0) == 42 + True + + """ + check_status( + w, + lib.GrB_Vector_extract( + w[0], + ffi.NULL if mask is None else mask[0], + ffi.NULL if accum is None else accum, + u[0], + indices, + ni, + ffi.NULL if desc is None else desc, + ), + ) + + +def vector_build_int64(w, indices, vals, nvals, dup): + """Build a vector from index and int64 value arrays. + + >>> w = vector_new(lib.GrB_INT64, 3) + >>> idx = np.array([0, 2], dtype=np.uint64) + >>> vals = np.array([10, 20], dtype=np.int64) + >>> vector_build_int64(w, idx, vals, 2, lib.GrB_PLUS_INT64) + >>> get_int64(w, 0) == 10 + True + >>> get_int64(w, 2) == 20 + True + + """ + check_status( + w, + lib.GrB_Vector_build_INT64( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int64_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_fp64(w, indices, vals, nvals, dup): + """Build a vector from index and fp64 value arrays. + + >>> w = vector_new(lib.GrB_FP64, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([1.5], dtype=np.float64) + >>> vector_build_fp64(w, idx, vals, 1, lib.GrB_PLUS_FP64) + >>> get_fp64(w, 0) == 1.5 + True + + """ + check_status( + w, + lib.GrB_Vector_build_FP64( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("double*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_extract_tuples_int64(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 42, 1) + >>> idx, vals = vector_extract_tuples_int64(v) + >>> len(vals) == 1 + True + >>> int(idx[0]) == 1 + True + >>> int(vals[0]) == 42 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_INT64( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int64_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_fp64(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_FP64, 3) + >>> set_fp64(v, 1.5, 0) + >>> idx, vals = vector_extract_tuples_fp64(v) + >>> len(vals) == 1 + True + >>> float(vals[0]) == 1.5 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.float64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_FP64( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("double*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_build_bool(w, indices, vals, nvals, dup): + """Build a vector from index and bool value arrays. + + >>> w = vector_new(lib.GrB_BOOL, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([True], dtype=np.bool_) + >>> vector_build_bool(w, idx, vals, 1, lib.GrB_FIRST_BOOL) + >>> get_bool(w, 0) == True + True + + """ + check_status( + w, + lib.GrB_Vector_build_BOOL( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("bool*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_int8(w, indices, vals, nvals, dup): + """Build a vector from index and int8 value arrays. + + >>> w = vector_new(lib.GrB_INT8, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int8) + >>> vector_build_int8(w, idx, vals, 1, lib.GrB_PLUS_INT8) + >>> get_int8(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_INT8( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int8_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_int16(w, indices, vals, nvals, dup): + """Build a vector from index and int16 value arrays. + + >>> w = vector_new(lib.GrB_INT16, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int16) + >>> vector_build_int16(w, idx, vals, 1, lib.GrB_PLUS_INT16) + >>> get_int16(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_INT16( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int16_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_int32(w, indices, vals, nvals, dup): + """Build a vector from index and int32 value arrays. + + >>> w = vector_new(lib.GrB_INT32, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.int32) + >>> vector_build_int32(w, idx, vals, 1, lib.GrB_PLUS_INT32) + >>> get_int32(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_INT32( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int32_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_uint8(w, indices, vals, nvals, dup): + """Build a vector from index and uint8 value arrays. + + >>> w = vector_new(lib.GrB_UINT8, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint8) + >>> vector_build_uint8(w, idx, vals, 1, lib.GrB_PLUS_UINT8) + >>> get_uint8(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_UINT8( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint8_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_uint16(w, indices, vals, nvals, dup): + """Build a vector from index and uint16 value arrays. + + >>> w = vector_new(lib.GrB_UINT16, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint16) + >>> vector_build_uint16(w, idx, vals, 1, lib.GrB_PLUS_UINT16) + >>> get_uint16(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_UINT16( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint16_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_uint32(w, indices, vals, nvals, dup): + """Build a vector from index and uint32 value arrays. + + >>> w = vector_new(lib.GrB_UINT32, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint32) + >>> vector_build_uint32(w, idx, vals, 1, lib.GrB_PLUS_UINT32) + >>> get_uint32(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_UINT32( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint32_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_uint64(w, indices, vals, nvals, dup): + """Build a vector from index and uint64 value arrays. + + >>> w = vector_new(lib.GrB_UINT64, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([7], dtype=np.uint64) + >>> vector_build_uint64(w, idx, vals, 1, lib.GrB_PLUS_UINT64) + >>> get_uint64(w, 0) == 7 + True + + """ + check_status( + w, + lib.GrB_Vector_build_UINT64( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint64_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_build_fp32(w, indices, vals, nvals, dup): + """Build a vector from index and fp32 value arrays. + + >>> w = vector_new(lib.GrB_FP32, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([1.5], dtype=np.float32) + >>> vector_build_fp32(w, idx, vals, 1, lib.GrB_PLUS_FP32) + >>> get_fp32(w, 0) == 1.5 + True + + """ + check_status( + w, + lib.GrB_Vector_build_FP32( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("float*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + +def vector_extract_tuples_bool(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_BOOL, 3) + >>> set_bool(v, True, 0) + >>> idx, vals = vector_extract_tuples_bool(v) + >>> len(vals) == 1 + True + >>> bool(vals[0]) == True + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.bool_) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_BOOL( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("bool*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_int8(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_INT8, 3) + >>> set_int8(v, 7, 0) + >>> idx, vals = vector_extract_tuples_int8(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int8) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_INT8( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int8_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_int16(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_INT16, 3) + >>> set_int16(v, 7, 0) + >>> idx, vals = vector_extract_tuples_int16(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int16) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_INT16( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int16_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_int32(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_INT32, 3) + >>> set_int32(v, 7, 0) + >>> idx, vals = vector_extract_tuples_int32(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.int32) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_INT32( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("int32_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_uint8(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_UINT8, 3) + >>> set_uint8(v, 7, 0) + >>> idx, vals = vector_extract_tuples_uint8(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint8) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_UINT8( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint8_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_uint16(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_UINT16, 3) + >>> set_uint16(v, 7, 0) + >>> idx, vals = vector_extract_tuples_uint16(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint16) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_UINT16( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint16_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_uint32(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_UINT32, 3) + >>> set_uint32(v, 7, 0) + >>> idx, vals = vector_extract_tuples_uint32(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint32) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_UINT32( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint32_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_uint64(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_UINT64, 3) + >>> set_uint64(v, 7, 0) + >>> idx, vals = vector_extract_tuples_uint64(v) + >>> len(vals) == 1 + True + >>> int(vals[0]) == 7 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.uint64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_UINT64( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("uint64_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def vector_extract_tuples_fp32(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GrB_FP32, 3) + >>> set_fp32(v, 1.5, 0) + >>> idx, vals = vector_extract_tuples_fp32(v) + >>> len(vals) == 1 + True + >>> float(vals[0]) == 1.5 + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.float32) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GrB_Vector_extractTuples_FP32( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("float*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + +def set_bool(v, value, i): + """Set a boolean value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_BOOL, 3) + >>> set_bool(v, True, 2) + >>> get_bool(v, 2) == True + True + + """ + check_status(v, lib.GrB_Vector_setElement_BOOL(v[0], value, i)) + + +def get_bool(v, i): + """Get a boolean value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_BOOL, 3) + >>> set_bool(v, True, 2) + >>> get_bool(v, 2) == True + True + + """ + value = ffi.new("bool*") + check_status(v, lib.GrB_Vector_extractElement_BOOL(value, v[0], i)) + return value[0] + + +def set_int8(v, value, i): + """Set an int8 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT8, 3) + >>> set_int8(v, 7, 2) + >>> get_int8(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_INT8(v[0], value, i)) + + +def get_int8(v, i): + """Get an int8 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT8, 3) + >>> set_int8(v, 7, 2) + >>> get_int8(v, 2) == 7 + True + + """ + value = ffi.new("int8_t*") + check_status(v, lib.GrB_Vector_extractElement_INT8(value, v[0], i)) + return value[0] + + +def set_int16(v, value, i): + """Set an int16 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT16, 3) + >>> set_int16(v, 7, 2) + >>> get_int16(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_INT16(v[0], value, i)) + + +def get_int16(v, i): + """Get an int16 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT16, 3) + >>> set_int16(v, 7, 2) + >>> get_int16(v, 2) == 7 + True + + """ + value = ffi.new("int16_t*") + check_status(v, lib.GrB_Vector_extractElement_INT16(value, v[0], i)) + return value[0] + + +def set_int32(v, value, i): + """Set an int32 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT32, 3) + >>> set_int32(v, 7, 2) + >>> get_int32(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_INT32(v[0], value, i)) + + +def get_int32(v, i): + """Get an int32 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT32, 3) + >>> set_int32(v, 7, 2) + >>> get_int32(v, 2) == 7 + True + + """ + value = ffi.new("int32_t*") + check_status(v, lib.GrB_Vector_extractElement_INT32(value, v[0], i)) + return value[0] + + +def set_int64(v, value, i): + """Set an int64 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 7, 2) + >>> get_int64(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_INT64(v[0], value, i)) + + +def get_int64(v, i): + """Get an int64 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_INT64, 3) + >>> set_int64(v, 7, 2) + >>> get_int64(v, 2) == 7 + True + + """ + value = ffi.new("int64_t*") + check_status(v, lib.GrB_Vector_extractElement_INT64(value, v[0], i)) + return value[0] + + +def set_uint8(v, value, i): + """Set a uint8 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT8, 3) + >>> set_uint8(v, 7, 2) + >>> get_uint8(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_UINT8(v[0], value, i)) + + +def get_uint8(v, i): + """Get a uint8 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT8, 3) + >>> set_uint8(v, 7, 2) + >>> get_uint8(v, 2) == 7 + True + + """ + value = ffi.new("uint8_t*") + check_status(v, lib.GrB_Vector_extractElement_UINT8(value, v[0], i)) + return value[0] + + +def set_uint16(v, value, i): + """Set a uint16 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT16, 3) + >>> set_uint16(v, 7, 2) + >>> get_uint16(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_UINT16(v[0], value, i)) + + +def get_uint16(v, i): + """Get a uint16 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT16, 3) + >>> set_uint16(v, 7, 2) + >>> get_uint16(v, 2) == 7 + True + + """ + value = ffi.new("uint16_t*") + check_status(v, lib.GrB_Vector_extractElement_UINT16(value, v[0], i)) + return value[0] + + +def set_uint32(v, value, i): + """Set a uint32 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT32, 3) + >>> set_uint32(v, 7, 2) + >>> get_uint32(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_UINT32(v[0], value, i)) + + +def get_uint32(v, i): + """Get a uint32 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT32, 3) + >>> set_uint32(v, 7, 2) + >>> get_uint32(v, 2) == 7 + True + + """ + value = ffi.new("uint32_t*") + check_status(v, lib.GrB_Vector_extractElement_UINT32(value, v[0], i)) + return value[0] + + +def set_uint64(v, value, i): + """Set a uint64 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT64, 3) + >>> set_uint64(v, 7, 2) + >>> get_uint64(v, 2) == 7 + True + + """ + check_status(v, lib.GrB_Vector_setElement_UINT64(v[0], value, i)) + + +def get_uint64(v, i): + """Get a uint64 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_UINT64, 3) + >>> set_uint64(v, 7, 2) + >>> get_uint64(v, 2) == 7 + True + + """ + value = ffi.new("uint64_t*") + check_status(v, lib.GrB_Vector_extractElement_UINT64(value, v[0], i)) + return value[0] + + +def set_fp32(v, value, i): + """Set an fp32 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_FP32, 3) + >>> set_fp32(v, 1.5, 2) + >>> get_fp32(v, 2) == 1.5 + True + + """ + check_status(v, lib.GrB_Vector_setElement_FP32(v[0], value, i)) + + +def get_fp32(v, i): + """Get an fp32 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_FP32, 3) + >>> set_fp32(v, 1.5, 2) + >>> get_fp32(v, 2) == 1.5 + True + + """ + value = ffi.new("float*") + check_status(v, lib.GrB_Vector_extractElement_FP32(value, v[0], i)) + return value[0] + + +def set_fp64(v, value, i): + """Set an fp64 value to the vector at position `i`. + + >>> v = vector_new(lib.GrB_FP64, 3) + >>> set_fp64(v, 1.5, 2) + >>> get_fp64(v, 2) == 1.5 + True + + """ + check_status(v, lib.GrB_Vector_setElement_FP64(v[0], value, i)) + + +def get_fp64(v, i): + """Get an fp64 value from the vector at position `i`. + + >>> v = vector_new(lib.GrB_FP64, 3) + >>> set_fp64(v, 1.5, 2) + >>> get_fp64(v, 2) == 1.5 + True + + """ + value = ffi.new("double*") + check_status(v, lib.GrB_Vector_extractElement_FP64(value, v[0], i)) + return value[0] + + +if supports_complex(): + + def set_fc32(v, value, i): + """Set an fc32 value to the vector at position `i`. + + >>> v = vector_new(lib.GxB_FC32, 3) + >>> set_fc32(v, 2+3j, 2) + >>> get_fc32(v, 2) == 2+3j + True + + """ + check_status(v, lib.GxB_Vector_setElement_FC32(v[0], value, i)) + + def get_fc32(v, i): + """Get an fc32 value from the vector at position `i`. + + >>> v = vector_new(lib.GxB_FC32, 3) + >>> set_fc32(v, 2+3j, 2) + >>> get_fc32(v, 2) == 2+3j + True + + """ + value = ffi.new("GxB_FC32_t*") + check_status(v, lib.GxB_Vector_extractElement_FC32(value, v[0], i)) + return value[0] + + def set_fc64(v, value, i): + """Set an fc64 value to the vector at position `i`. + + >>> v = vector_new(lib.GxB_FC64, 3) + >>> set_fc64(v, 2+3j, 2) + >>> get_fc64(v, 2) == 2+3j + True + + """ + check_status(v, lib.GxB_Vector_setElement_FC64(v[0], value, i)) + + def get_fc64(v, i): + """Get an fc64 value from the vector at position `i`. + + >>> v = vector_new(lib.GxB_FC64, 3) + >>> set_fc64(v, 2+3j, 2) + >>> get_fc64(v, 2) == 2+3j + True + + """ + value = ffi.new("GxB_FC64_t*") + check_status(v, lib.GxB_Vector_extractElement_FC64(value, v[0], i)) + return value[0] + + def vector_build_fc32(w, indices, vals, nvals, dup): + """Build a vector from index and fc32 value arrays. + + >>> w = vector_new(lib.GxB_FC32, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([2+3j], dtype=np.complex64) + >>> vector_build_fc32(w, idx, vals, 1, lib.GxB_PLUS_FC32) + >>> get_fc32(w, 0) == 2+3j + True + + """ + check_status( + w, + lib.GxB_Vector_build_FC32( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("GxB_FC32_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + def vector_extract_tuples_fc32(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GxB_FC32, 3) + >>> set_fc32(v, 2+3j, 0) + >>> idx, vals = vector_extract_tuples_fc32(v) + >>> len(vals) == 1 + True + >>> complex(vals[0]) == 2+3j + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.complex64) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GxB_Vector_extractTuples_FC32( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("GxB_FC32_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals + + def vector_build_fc64(w, indices, vals, nvals, dup): + """Build a vector from index and fc64 value arrays. + + >>> w = vector_new(lib.GxB_FC64, 3) + >>> idx = np.array([0], dtype=np.uint64) + >>> vals = np.array([2+3j], dtype=np.complex128) + >>> vector_build_fc64(w, idx, vals, 1, lib.GxB_PLUS_FC64) + >>> get_fc64(w, 0) == 2+3j + True + + """ + check_status( + w, + lib.GxB_Vector_build_FC64( + w[0], + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("GxB_FC64_t*", ffi.from_buffer(vals)), + nvals, + dup, + ), + ) + + def vector_extract_tuples_fc64(v): + """Extract all tuples from a vector as numpy arrays. + + Returns (indices, vals) as numpy arrays. + + >>> v = vector_new(lib.GxB_FC64, 3) + >>> set_fc64(v, 2+3j, 0) + >>> idx, vals = vector_extract_tuples_fc64(v) + >>> len(vals) == 1 + True + >>> complex(vals[0]) == 2+3j + True + + """ + n = vector_nvals(v) + indices = np.empty(n, dtype=np.uint64) + vals = np.empty(n, dtype=np.complex128) + nvals_p = ffi.new("GrB_Index*", n) + if n > 0: + check_status( + v, + lib.GxB_Vector_extractTuples_FC64( + ffi.cast("GrB_Index*", ffi.from_buffer(indices)), + ffi.cast("GxB_FC64_t*", ffi.from_buffer(vals)), + nvals_p, + v[0], + ), + ) + return indices, vals diff --git a/suitesparse_graphblas/conftest.py b/suitesparse_graphblas/conftest.py new file mode 100644 index 0000000..4e25e1d --- /dev/null +++ b/suitesparse_graphblas/conftest.py @@ -0,0 +1,29 @@ +import pytest + +from suitesparse_graphblas import initialize + +try: + from numpy._core._multiarray_umath import _set_numpy_warn_if_no_mem_policy +except ImportError: # pragma: no cover + try: # NumPy < 2 + from numpy.core._multiarray_umath import _set_numpy_warn_if_no_mem_policy + except ImportError: # private, so it may go away + _set_numpy_warn_if_no_mem_policy = None + + +@pytest.fixture(scope="session", autouse=True) +def intialize_suitesparse_graphblas(): + initialize() + + +@pytest.fixture(scope="session", autouse=True) +def warn_if_no_memory_handler(): + # NumPy frees the data of an array that owns it but has no memory handler with libc + # `free`, which is only right by luck (see utils.pyx). Make NumPy warn when it does; + # the warning fails the test (see `filterwarnings` in pyproject.toml). + if _set_numpy_warn_if_no_mem_policy is None: # pragma: no cover + yield + return + old = _set_numpy_warn_if_no_mem_policy(True) + yield + _set_numpy_warn_if_no_mem_policy(old) diff --git a/suitesparse/graphblas/create_headers.py b/suitesparse_graphblas/create_headers.py similarity index 76% rename from suitesparse/graphblas/create_headers.py rename to suitesparse_graphblas/create_headers.py index 74a5b8a..59d5e8c 100644 --- a/suitesparse/graphblas/create_headers.py +++ b/suitesparse_graphblas/create_headers.py @@ -21,18 +21,20 @@ Run `python create_headers.py --help` to see more help. """ + import argparse import os import re import shutil import subprocess import sys + import pycparser from pycparser import c_ast, c_generator, parse_file def sort_key(string): - """ e.g., sort 'INT8' before 'INT16'""" + """e.g., sort 'INT8' before 'INT16'""" return string.replace("8", "08") @@ -54,6 +56,8 @@ def groupby(index, seq): AUTO = "/* This file is automatically generated */" DEPRECATED = { + # Strongly deprecated in SuiteSparse:GraphBLAS 10; will be removed in 11 + "GrB_Field", # enums "GxB_IS_HYPER", "GrB_SCMP", @@ -260,6 +264,7 @@ def groupby(index, seq): } DEFINES = { + "GrB_INDEX_MAX", "GxB_STDC_VERSION", "GxB_IMPLEMENTATION_MAJOR", "GxB_IMPLEMENTATION_MINOR", @@ -274,8 +279,8 @@ def groupby(index, seq): "GRB_SUBVERSION", "GxB_NTHREADS", "GxB_CHUNK", - "GxB_GPU_CONTROL", - "GxB_GPU_CHUNK", + "GxB_GPU_IDS", + "GxB_NGPUS", "GxB_HYPERSPARSE", "GxB_SPARSE", "GxB_BITMAP", @@ -289,6 +294,19 @@ def groupby(index, seq): "GxB_BEGIN", "GxB_END", "GxB_INC", + "GxB_FAST_IMPORT", + "GxB_MAX_NAME_LEN", + "GxB_COMPRESSION_DEFAULT", + "GxB_COMPRESSION_LZ4", + "GxB_COMPRESSION_LZ4HC", + "GxB_COMPRESSION_ZSTD", + "GxB_COMPRESSION_NONE", + "GxB_USE_VALUES", + # Memory arenas, added in version 10.4 + "GxB_ARENA_DATA", + "GxB_ARENA_HEADER", + "GxB_NARENAS", + "GxB_NARENAS_GPU", # Added in version 10.5.2 } CHAR_DEFINES = { @@ -301,16 +319,43 @@ def groupby(index, seq): } IGNORE_DEFINES = { + "GrB", + "GxB", "CMPLX", "CMPLXF", + "GB_GLOBAL", + "GB_HAS_CMPLX_MACROS", "GB_PUBLIC", + "GB_restrict", "GRAPHBLAS_H", "GrB_INVALID_HANDLE", "GrB_NULL", "GxB_SUITESPARSE_GRAPHBLAS", "NMACRO", + "RMM_WRAP_H", + "GXB_COMPLEX_H", + "GxB_STATIC_INLINE_VOID", + "GxB_HAVE_COMPLEX_C99", # deprecated "GxB_HYPER", + "GxB_NONBLOCKING_GPU", # GrB_Mode values until 10.5.2; now aliases of GrB_NONBLOCKING + "GxB_BLOCKING_GPU", # and GrB_BLOCKING +} + +IGNORE_LINES = { + "GxB_cuda_calloc", + "GxB_cuda_malloc", + "GxB_cuda_free", +} + +# Declared in GraphBLAS.h, but not actually defined by libgraphblas. cffi would +# happily bind these, but then importing `_graphblas` fails at dlopen time with +# "symbol not found in flat namespace". Remove entries here once upstream +# implements them. This is most common in beta releases. +NOT_IMPLEMENTED = set() +IGNORE_ENUMS = { + "memory_order", + "RMM_MODE", } @@ -326,6 +371,22 @@ def visit_Typedef(self, node): return rv +class VisitStruct(c_generator.CGenerator): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.results = [] + + def visit_Struct(self, node): + rv = super().visit_Struct(node) + if ( + ("GxB_" in node.name or "GrB_" in node.name) + and "_struct" in node.name + and node.decls is not None + ): + self.results.append(rv + ";") + return rv + + def get_ast(filename): fake_include = os.path.dirname(pycparser.__file__) + "utils/fake_libc_include" ast = parse_file(filename, cpp_args=f"-I{fake_include}") @@ -338,20 +399,24 @@ def get_groups(ast): seen = set() groups = {} - vals = {x for x in lines if "extern GrB_Info GxB" in x} - seen + vals = {x for x in lines if "GrB_Info GxB" in x} - seen + vals |= {x for x in lines if "GxB_Iterator" in x and "GB" not in x} - seen + # A few GxB functions return void, e.g. GxB_atfork_* (added in v10.4.0) + vals |= {x for x in lines if x.startswith("void GxB")} - seen seen.update(vals) groups["GxB methods"] = sorted(vals, key=sort_key) - vals = {x for x in lines if "extern GrB_Info GrB" in x} - seen + vals = {x for x in lines if "GrB_Info GrB" in x} - seen seen.update(vals) groups["GrB methods"] = sorted(vals, key=sort_key) - vals = {x for x in lines if "extern GrB_Info GB" in x} - seen + vals = {x for x in lines if "GrB_Info GB" in x} - seen + vals |= {x for x in lines if "GxB_Iterator" in x and "GB" in x and "typedef" not in x} - seen seen.update(vals) groups["GB methods"] = sorted(vals, key=sort_key) - missing_methods = {x for x in lines if "extern GrB_Info " in x} - seen - assert not missing_methods + missing_methods = {x for x in lines if "GrB_Info " in x} - seen + assert not missing_methods, ", ".join(sorted(missing_methods)) vals = {x for x in lines if "extern GrB" in x} - seen seen.update(vals) @@ -370,7 +435,7 @@ def get_groups(ast): groups["GrB const"] = sorted(vals, key=sort_key) missing_const = {x for x in lines if "extern const" in x} - seen - assert not missing_const + assert not missing_const, ", ".join(sorted(missing_const)) vals = {x for x in lines if "typedef" in x and "GxB" in x and "(" not in x} - seen seen.update(vals) @@ -380,10 +445,8 @@ def get_groups(ast): seen.update(vals) groups["GrB typedef"] = sorted(vals, key=sort_key) - missing_typedefs = { - x for x in lines if "typedef" in x and "GB" in x and "(" not in x - } - seen - assert not missing_typedefs + missing_typedefs = {x for x in lines if "typedef" in x and "GB" in x and "(" not in x} - seen + assert not missing_typedefs, ", ".join(sorted(missing_typedefs)) assert all(x.endswith(";") for x in seen) # sanity check g = VisitEnumTypedef() @@ -393,31 +456,58 @@ def get_groups(ast): vals = {x for x in enums if "} GrB" in x} for val in vals: seen.update(val.splitlines()) - groups["GrB typedef enums"] = sorted( - vals, key=lambda x: sort_key(x.rsplit("}", 1)[-1]) - ) + groups["GrB typedef enums"] = sorted(vals, key=lambda x: sort_key(x.rsplit("}", 1)[-1])) vals = {x for x in enums if "} GxB" in x} for val in vals: seen.update(val.splitlines()) - groups["GxB typedef enums"] = sorted( - vals, key=lambda x: sort_key(x.rsplit("}", 1)[-1]) - ) + groups["GxB typedef enums"] = sorted(vals, key=lambda x: sort_key(x.rsplit("}", 1)[-1])) - missing_enums = ( - set(enums) - set(groups["GrB typedef enums"]) - set(groups["GxB typedef enums"]) - ) - assert not missing_enums + g = VisitStruct() + _ = g.visit(ast) + structs = g.results + + # No non-opaque GrB structs yet + # vals = {x for x in structs if "struct GrB" in x} + # for val in vals: + # seen.update(val.splitlines()) + # groups["GrB struct"] = sorted(vals) + + vals = {x for x in structs if "struct GxB" in x} + for val in vals: + seen.update(val.splitlines()) + groups["GxB struct"] = sorted(vals) + + missing_enums = set(enums) - set(groups["GrB typedef enums"]) - set(groups["GxB typedef enums"]) + missing_enums = {x for x in missing_enums if not any(y in x for y in IGNORE_ENUMS)} + assert not missing_enums, ", ".join(sorted(missing_enums)) vals = {x for x in lines if "typedef" in x and "GxB" in x} - seen seen.update(vals) groups["GxB typedef funcs"] = sorted(vals, key=sort_key) vals = {x for x in lines if "typedef" in x and "GrB" in x} - seen - assert not vals + assert not vals, ", ".join(sorted(vals)) groups["not seen"] = sorted(set(lines) - seen, key=sort_key) for group in groups["not seen"]: assert "extern" not in group, group + + unhandled = set() + for line in groups["not seen"]: + if "GrB" in line or "GxB" in line: + for item in IGNORE_LINES: + if item in line: + break + else: + unhandled.add(line) + if unhandled: + raise ValueError( + "\n===================================\n" + "Unhandled functions with GrB or GxB\n" + "-----------------------------------\n " + + "\n ".join(sorted(unhandled)) + + "\n===================================" + ) return groups @@ -541,18 +631,29 @@ def handle_typedef_funcs(group): rv["GxB typedef funcs"] = list(handle_typedef_funcs(groups["GxB typedef funcs"])) + def handle_structs(group): + for text in group: + yield {"text": text} + + rv["GxB struct"] = list(handle_structs(groups["GxB struct"])) + class FuncDeclVisitor(c_ast.NodeVisitor): def __init__(self): self.functions = [] def visit_Decl(self, node): - if isinstance(node.type, c_ast.FuncDecl) and node.storage == ["extern"]: + if isinstance(node.type, c_ast.FuncDecl) and node.storage == []: self.functions.append(node) def handle_function_node(node): - if generator.visit(node.type.type) != "GrB_Info": + if ( + generator.visit(node.type.type) != "GrB_Info" + and "GxB_Iterator" not in generator.visit(node) + # e.g. GxB_atfork_* (added in v10.4.0) return void + and not (node.name.startswith("GxB_") and generator.visit(node.type.type) == "void") + ): raise ValueError(generator.visit(node)) - if node.name in DEPRECATED: + if node.name in DEPRECATED or node.name in NOT_IMPLEMENTED: return text = generator.visit(node) text += ";" @@ -562,13 +663,16 @@ def handle_function_node(node): group = "matrix" elif "GrB_Vector" in text: group = "vector" - elif "GxB_Scalar" in text: + elif "GxB_Scalar" in text or "GrB_Scalar" in text: group = "scalar" + elif "GxB_Iterator" in text: + group = "iterator" else: group = node.name.split("_", 2)[1] group = { # Apply our naming scheme "GrB_Matrix": "matrix", + "Matrix": "matrix", "GrB_Vector": "vector", "GxB_Scalar": "scalar", "SelectOp": "selectop", @@ -579,6 +683,11 @@ def handle_function_node(node): "Semiring": "semiring", "Type": "type", "UnaryOp": "unary", + "IndexUnaryOp": "indexunary", + "IndexBinaryOp": "indexbinary", + "Iterator": "iterator", + "Context": "context", + "Container": "container", # "everything else" is "core" "getVersion": "core", "Global": "core", @@ -586,6 +695,12 @@ def handle_function_node(node): "finalize": "core", "init": "core", "wait": "core", + "deserialize": "core", + "Serialized": "core", # Added in version 9 + "arena": "core", # Added in version 10.4 + "atfork": "core", # Added in version 10.4 + "initialized": "core", # Added in version 10.4 + "finalized": "core", # Added in version 10.4 }[group] return { "name": node.name, @@ -600,9 +715,22 @@ def handle_function_node(node): grb_nodes = [node for node in visitor.functions if node.name.startswith("GrB_")] gxb_nodes = [node for node in visitor.functions if node.name.startswith("GxB_")] gb_nodes = [node for node in visitor.functions if node.name.startswith("GB_")] - assert len(grb_nodes) == len(groups["GrB methods"]) - assert len(gxb_nodes) == len(groups["GxB methods"]) - assert len(gb_nodes) == len(groups["GB methods"]) + assert len(grb_nodes) == len(groups["GrB methods"]), ( + len(grb_nodes), + len(groups["GrB methods"]), + ) + + # Temporary hack for v10.0.1, which duplicates `GxB_Serialized_get_Scalar` + temp_seen = set() + gxb_nodes = [ + temp_seen.add(node.name) or node for node in gxb_nodes if node.name not in temp_seen + ] + + assert len(gxb_nodes) == len(groups["GxB methods"]), ( + len(gxb_nodes), + len(groups["GxB methods"]), + ) + assert len(gb_nodes) == len(groups["GB methods"]), (len(gb_nodes), len(groups["GB methods"])) grb_funcs = (handle_function_node(node) for node in grb_nodes) gxb_funcs = (handle_function_node(node) for node in gxb_nodes) @@ -644,6 +772,10 @@ def create_header_text(groups, *, char_defines=None, defines=None): for group in groups["GxB typedef funcs"]: text.append(group["text"]) text.append("") + text.append("/* GxB structs */") + for group in groups["GxB struct"]: + text.append(group["text"]) + text.append("") text.append("/* GrB enums */") for group in groups["GrB typedef enums"]: text.append(group["text"]) @@ -712,7 +844,7 @@ def handle_funcs(group): return text -def create_source_text(*, char_defines=None): +def create_source_text(groups, *, char_defines=None): if char_defines is None: char_defines = CHAR_DEFINES text = [ @@ -729,7 +861,7 @@ def main(): parser.add_argument( "--graphblas", help="Path to GraphBLAS.h of SuiteSparse. Default will look in Python prefix path.", - default=os.path.join(sys.prefix, "include", "GraphBLAS.h"), + default=os.path.join(sys.prefix, "include", "suitesparse", "GraphBLAS.h"), ) parser.add_argument( "--show-skipped", @@ -746,6 +878,7 @@ def main(): # final files used by cffi (with and without complex numbers) final_h = os.path.join(thisdir, "suitesparse_graphblas.h") + # final_arm64_h = os.path.join(thisdir, "suitesparse_graphblas_arm64.h") final_no_complex_h = os.path.join(thisdir, "suitesparse_graphblas_no_complex.h") source_c = os.path.join(thisdir, "source.c") @@ -757,9 +890,7 @@ def main(): # Run it through the preprocessor print(f"Step 2: run preprocessor to create {processed_h}") - include = os.path.join( - os.path.dirname(pycparser.__file__), "utils", "fake_libc_include" - ) + include = os.path.join(os.path.dirname(pycparser.__file__), "utils", "fake_libc_include") command = ( f"gcc -nostdinc -E -I{include} {graphblas_h} " f"| sed 's/ complex / _Complex /g' > {processed_h}" @@ -773,27 +904,41 @@ def main(): groups = parse_header(processed_h, skip_complex=False) text = create_header_text(groups) with open(final_h, "w") as f: - f.write("\n".join(text)) + f.write("\n".join(text) + "\n") + + # NOTE:suitesparse_graphblas.h and suitesparse_graphblas_arm64.h are the same now + # # Create final header file (arm64) + # # Replace all variadic arguments (...) with "char *" + # print(f"Step 4: parse header file to create {final_arm64_h}") + # orig_text = text + # patt = re.compile(r"^(extern GrB_Info .*\(.*)(\.\.\.)(\);)$") + # text = [patt.sub(r"\1char *\3", line) for line in orig_text] + # with open(final_arm64_h, "w") as f: + # f.write("\n".join(text) + "\n") # Create final header file (no complex) print(f"Step 4: parse header file to create {final_no_complex_h}") groups_no_complex = parse_header(processed_h, skip_complex=True) text = create_header_text(groups_no_complex) with open(final_no_complex_h, "w") as f: - f.write("\n".join(text)) + f.write("\n".join(text) + "\n") # Create source print(f"Step 5: create {source_c}") - text = create_source_text() + text = create_source_text(groups) with open(source_c, "w") as f: - f.write("\n".join(text)) + f.write("\n".join(text) + "\n") # Check defines print("Step 6: check #define definitions") with open(graphblas_h) as f: text = f.read() + define_lines = re.compile(r".*?#define\s+\w+\s+") define_pattern = re.compile(r"#define\s+\w+\s+") - defines = {x[len("#define") :].strip() for x in define_pattern.findall(text)} + defines = set() + for line in define_lines.findall(text): + line = line.split("//")[0].split("/*")[0] + defines.update(x[len("#define") :].strip() for x in define_pattern.findall(line)) extra_defines = (DEFINES | CHAR_DEFINES) - defines if extra_defines: # Should this raise? If it's a problem, it will raise when compiling. @@ -804,15 +949,12 @@ def main(): unknown_defines = defines - DEFINES - CHAR_DEFINES - IGNORE_DEFINES if unknown_defines: raise ValueError( - f"Unknown #define values found in {graphblas_h}: " - + ", ".join(sorted(unknown_defines)) + f"Unknown #define values found in {graphblas_h}: " + ", ".join(sorted(unknown_defines)) ) print("Success!", "\N{ROCKET}") if args.show_skipped: print() - print( - f"Showing lines from {processed_h} that were skipped when creating {final_h}:" - ) + print(f"Showing lines from {processed_h} that were skipped when creating {final_h}:") print("-" * 80) for line in sorted(groups["not seen"], key=sort_key): print(line) diff --git a/suitesparse_graphblas/exceptions.py b/suitesparse_graphblas/exceptions.py new file mode 100644 index 0000000..3761228 --- /dev/null +++ b/suitesparse_graphblas/exceptions.py @@ -0,0 +1,66 @@ +class GraphBLASException(Exception): + pass + + +class NoValue(GraphBLASException): + pass + + +class UninitializedObject(GraphBLASException): + pass + + +class InvalidObject(GraphBLASException): + pass + + +class NullPointer(GraphBLASException): + pass + + +class InvalidValue(GraphBLASException): + pass + + +class InvalidIndex(GraphBLASException): + pass + + +class DomainMismatch(GraphBLASException): + pass + + +class DimensionMismatch(GraphBLASException): + pass + + +class OutputNotEmpty(GraphBLASException): + pass + + +class EmptyObject(GraphBLASException): + pass + + +class OutOfMemory(GraphBLASException): + pass + + +class InsufficientSpace(GraphBLASException): + pass + + +class IndexOutOfBound(GraphBLASException): + pass + + +class Panic(GraphBLASException): + pass + + +class NotImplementedException(GraphBLASException): + pass + + +class JitError(GraphBLASException): + pass diff --git a/suitesparse_graphblas/io/__init__.py b/suitesparse_graphblas/io/__init__.py new file mode 100644 index 0000000..b2d6f38 --- /dev/null +++ b/suitesparse_graphblas/io/__init__.py @@ -0,0 +1 @@ +from suitesparse_graphblas.api.io import binary, serialize # noqa: F401 diff --git a/suitesparse/graphblas/source.c b/suitesparse_graphblas/source.c similarity index 89% rename from suitesparse/graphblas/source.c rename to suitesparse_graphblas/source.c index fa5fae3..9309c64 100644 --- a/suitesparse/graphblas/source.c +++ b/suitesparse_graphblas/source.c @@ -5,4 +5,4 @@ char *GxB_IMPLEMENTATION_DATE_STR = GxB_IMPLEMENTATION_DATE; char *GxB_IMPLEMENTATION_LICENSE_STR = GxB_IMPLEMENTATION_LICENSE; char *GxB_IMPLEMENTATION_NAME_STR = GxB_IMPLEMENTATION_NAME; char *GxB_SPEC_ABOUT_STR = GxB_SPEC_ABOUT; -char *GxB_SPEC_DATE_STR = GxB_SPEC_DATE; \ No newline at end of file +char *GxB_SPEC_DATE_STR = GxB_SPEC_DATE; diff --git a/suitesparse_graphblas/suitesparse_graphblas.h b/suitesparse_graphblas/suitesparse_graphblas.h new file mode 100644 index 0000000..30dc2f9 --- /dev/null +++ b/suitesparse_graphblas/suitesparse_graphblas.h @@ -0,0 +1,3862 @@ +/* This file is automatically generated */ +/* GrB typedefs */ +typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; +typedef struct GB_Descriptor_opaque *GrB_Descriptor; +typedef struct GB_Global_opaque *GrB_Global; +typedef struct GB_IndexUnaryOp_opaque *GrB_IndexUnaryOp; +typedef struct GB_Matrix_opaque *GrB_Matrix; +typedef struct GB_Monoid_opaque *GrB_Monoid; +typedef struct GB_Scalar_opaque *GrB_Scalar; +typedef struct GB_Semiring_opaque *GrB_Semiring; +typedef struct GB_Type_opaque *GrB_Type; +typedef struct GB_UnaryOp_opaque *GrB_UnaryOp; +typedef struct GB_Vector_opaque *GrB_Vector; +typedef uint64_t GrB_Index; + +/* GxB typedefs */ +typedef double _Complex GxB_FC64_t; +typedef float _Complex GxB_FC32_t; +typedef struct GB_Context_opaque *GxB_Context; +typedef struct GB_IndexBinaryOp_opaque *GxB_IndexBinaryOp; +typedef struct GB_Iterator_opaque *GxB_Iterator; +typedef struct GB_Scalar_opaque *GxB_Scalar; +typedef struct GB_SelectOp_opaque *GxB_SelectOp; +typedef struct GxB_Container_struct *GxB_Container; + +/* GxB typedefs (functions) */ +typedef int64_t (*GxB_print_function)(char *string, size_t string_len, const void *value, int verbose); +typedef void (*GxB_binary_function)(void *, const void *, const void *); +typedef void (*GxB_index_binary_function)(void *, const void *, GrB_Index, GrB_Index, const void *, GrB_Index, GrB_Index, const void *); +typedef void (*GxB_index_unary_function)(void *z, const void *x, GrB_Index i, GrB_Index j, const void *y); +typedef void (*GxB_unary_function)(void *, const void *); + +/* GxB structs */ +struct GxB_Container_struct +{ + uint64_t nrows; + uint64_t ncols; + int64_t nrows_nonempty; + int64_t ncols_nonempty; + uint64_t nvals; + uint64_t u64_future[11]; + int32_t format; + int32_t orientation; + int32_t header_arena; + uint32_t u32_future[13]; + GrB_Vector p; + GrB_Vector h; + GrB_Vector b; + GrB_Vector i; + GrB_Vector x; + GrB_Vector vector_future[11]; + GrB_Matrix Y; + GrB_Matrix matrix_future[15]; + bool iso; + bool jumbled; + bool bool_future[30]; + void *void_future[16]; +}; + +/* GrB enums */ +typedef enum +{ + GrB_OUTP = 0, + GrB_MASK = 1, + GrB_INP0 = 2, + GrB_INP1 = 3, + GxB_AxB_METHOD = 7090, + GxB_SORT = 7091, + GxB_COMPRESSION = 7092, + GxB_IMPORT = 7093, + GxB_ROWINDEX_LIST = 7094, + GxB_COLINDEX_LIST = 7095, + GxB_VALUE_LIST = 7096 +} GrB_Desc_Field; + +typedef enum +{ + GrB_DEFAULT = 0, + GxB_DEFAULT = 0, + GrB_REPLACE = 1, + GrB_COMP = 2, + GrB_STRUCTURE = 4, + GrB_COMP_STRUCTURE = 6, + GrB_TRAN = 3, + GxB_AxB_GUSTAVSON = 7081, + GxB_AxB_DOT = 7083, + GxB_AxB_HASH = 7084, + GxB_AxB_SAXPY = 7085, + GxB_SECURE_IMPORT = 7080, + GxB_USE_INDICES = 7060, + GxB_IS_STRIDE = 7061 +} GrB_Desc_Value; + +typedef enum +{ + GrB_CSR_FORMAT = 0, + GrB_CSC_FORMAT = 1, + GrB_COO_FORMAT = 2 +} GrB_Format; + +typedef enum +{ + GrB_SUCCESS = 0, + GrB_NO_VALUE = 1, + GxB_EXHAUSTED = 7089, + GrB_UNINITIALIZED_OBJECT = -1, + GrB_NULL_POINTER = -2, + GrB_INVALID_VALUE = -3, + GrB_INVALID_INDEX = -4, + GrB_DOMAIN_MISMATCH = -5, + GrB_DIMENSION_MISMATCH = -6, + GrB_OUTPUT_NOT_EMPTY = -7, + GrB_NOT_IMPLEMENTED = -8, + GrB_ALREADY_SET = -9, + GrB_PANIC = -101, + GrB_OUT_OF_MEMORY = -102, + GrB_INSUFFICIENT_SPACE = -103, + GrB_INVALID_OBJECT = -104, + GrB_INDEX_OUT_OF_BOUNDS = -105, + GrB_EMPTY_OBJECT = -106, + GxB_JIT_ERROR = -7001, + GxB_GPU_ERROR = -7002, + GxB_OUTPUT_IS_READONLY = -7003 +} GrB_Info; + +typedef enum +{ + GrB_NONBLOCKING = 0, + GrB_BLOCKING = 1 +} GrB_Mode; + +typedef enum +{ + GrB_ROWMAJOR = 0, + GrB_COLMAJOR = 1, + GrB_BOTH = 2, + GrB_UNKNOWN = 3 +} GrB_Orientation; + +typedef enum +{ + GrB_UDT_CODE = 0, + GrB_BOOL_CODE = 1, + GrB_INT8_CODE = 2, + GrB_UINT8_CODE = 3, + GrB_INT16_CODE = 4, + GrB_UINT16_CODE = 5, + GrB_INT32_CODE = 6, + GrB_UINT32_CODE = 7, + GrB_INT64_CODE = 8, + GrB_UINT64_CODE = 9, + GrB_FP32_CODE = 10, + GrB_FP64_CODE = 11, + GxB_FC32_CODE = 7070, + GxB_FC64_CODE = 7071 +} GrB_Type_Code; + +typedef enum +{ + GrB_COMPLETE = 0, + GrB_MATERIALIZE = 1 +} GrB_WaitMode; + +/* GxB enums */ +typedef enum +{ + GxB_CONTEXT_NTHREADS = 7086, + GxB_CONTEXT_CHUNK = 7087, + GxB_CONTEXT_NGPUS = 7102, + GxB_CONTEXT_GPU_IDS = 7101 +} GxB_Context_Field; + +typedef enum +{ + GxB_BY_ROW = 0, + GxB_BY_COL = 1, + GxB_NO_FORMAT = -1 +} GxB_Format_Value; + +typedef enum +{ + GxB_JIT_OFF = 0, + GxB_JIT_PAUSE = 1, + GxB_JIT_RUN = 2, + GxB_JIT_LOAD = 3, + GxB_JIT_ON = 4 +} GxB_JIT_Control; + +typedef enum +{ + GrB_OUTP_FIELD = 0, + GrB_MASK_FIELD = 1, + GrB_INP0_FIELD = 2, + GrB_INP1_FIELD = 3, + GrB_NAME = 10, + GrB_LIBRARY_VER_MAJOR = 11, + GrB_LIBRARY_VER_MINOR = 12, + GrB_LIBRARY_VER_PATCH = 13, + GrB_API_VER_MAJOR = 14, + GrB_API_VER_MINOR = 15, + GrB_API_VER_PATCH = 16, + GrB_BLOCKING_MODE = 17, + GrB_STORAGE_ORIENTATION_HINT = 100, + GrB_EL_TYPE_CODE = 102, + GrB_EL_TYPE_STRING = 106, + GrB_INP0_TYPE_CODE = 103, + GrB_INP1_TYPE_CODE = 104, + GrB_OUTP_TYPE_CODE = 105, + GrB_INP0_TYPE_STRING = 107, + GrB_INP1_TYPE_STRING = 108, + GrB_OUTP_TYPE_STRING = 109, + GrB_SIZE = 110, + GxB_JIT_C_NAME = 7041, + GxB_JIT_C_DEFINITION = 7042, + GxB_MONOID_IDENTITY = 7043, + GxB_MONOID_TERMINAL = 7044, + GxB_MONOID_OPERATOR = 7045, + GxB_SEMIRING_MONOID = 7046, + GxB_SEMIRING_MULTIPLY = 7047, + GxB_THETA_TYPE_CODE = 7050, + GxB_THETA_TYPE_STRING = 7051, + GxB_THETA = 7052, + GxB_ROWINDEX_INTEGER_HINT = 7053, + GxB_COLINDEX_INTEGER_HINT = 7054, + GxB_OFFSET_INTEGER_HINT = 7056, + GxB_HYPER_SWITCH = 7000, + GxB_HYPER_HASH = 7048, + GxB_BITMAP_SWITCH = 7001, + GxB_FORMAT = 7002, + GxB_ISO = 7079, + GxB_SPARSITY_CONTROL = 7036, + GxB_ROWINDEX_INTEGER_BITS = 7057, + GxB_COLINDEX_INTEGER_BITS = 7058, + GxB_OFFSET_INTEGER_BITS = 7059, + GxB_SPARSITY_STATUS = 7034, + GxB_IS_READONLY = 7078, + GxB_WILL_WAIT = 7076, + GxB_MODE = 7003, + GxB_LIBRARY_NAME = 7004, + GxB_LIBRARY_VERSION = 7005, + GxB_LIBRARY_DATE = 7006, + GxB_LIBRARY_ABOUT = 7007, + GxB_LIBRARY_URL = 7008, + GxB_LIBRARY_LICENSE = 7009, + GxB_LIBRARY_COMPILE_DATE = 7010, + GxB_LIBRARY_COMPILE_TIME = 7011, + GxB_API_VERSION = 7012, + GxB_API_DATE = 7013, + GxB_API_ABOUT = 7014, + GxB_API_URL = 7015, + GxB_COMPILER_VERSION = 7016, + GxB_COMPILER_NAME = 7017, + GxB_LIBRARY_OPENMP = 7018, + GxB_MALLOC_FUNCTION = 7037, + GxB_CALLOC_FUNCTION = 7038, + GxB_REALLOC_FUNCTION = 7039, + GxB_FREE_FUNCTION = 7040, + GxB_ARENA_MALLOC = 0x10000, + GxB_ARENA_CALLOC = 0x20000, + GxB_ARENA_REALLOC = 0x30000, + GxB_ARENA_FREE = 0x40000, + GxB_GLOBAL_NTHREADS = 7086, + GxB_GLOBAL_CHUNK = 7087, + GxB_GLOBAL_NGPUS = 7102, + GxB_GLOBAL_GPU_IDS = 7101, + GxB_NGPUS_MAX = 7103, + GxB_BURBLE = 7019, + GxB_PRINTF = 7020, + GxB_FLUSH = 7021, + GxB_MEMORY_POOL = 7022, + GxB_PRINT_1BASED = 7023, + GxB_INCLUDE_READONLY_STATISTICS = 7077, + GxB_JIT_C_COMPILER_NAME = 7024, + GxB_JIT_C_COMPILER_FLAGS = 7025, + GxB_JIT_C_LINKER_FLAGS = 7026, + GxB_JIT_C_LIBRARIES = 7027, + GxB_JIT_C_PREFACE = 7028, + GxB_JIT_C_CONTROL = 7029, + GxB_JIT_CACHE_PATH = 7030, + GxB_JIT_C_CMAKE_LIBS = 7031, + GxB_JIT_USE_CMAKE = 7032, + GxB_JIT_ERROR_LOG = 7033, + GxB_JIT_CUDA_PREFACE = 7100, + GxB_PRINT_FUNCTION = 7104 +} GxB_Option_Field; + +typedef enum +{ + GxB_SILENT = 0, + GxB_SUMMARY = 1, + GxB_SHORT = 2, + GxB_COMPLETE = 3, + GxB_SHORT_VERBOSE = 4, + GxB_COMPLETE_VERBOSE = 5 +} GxB_Print_Level; + +/* GrB consts */ +extern const GrB_Global GrB_GLOBAL; +extern const uint64_t *GrB_ALL; + +/* GxB consts */ +extern const double GxB_ALWAYS_HYPER; +extern const double GxB_HYPER_DEFAULT; +extern const double GxB_NEVER_HYPER; +extern const int GxB_FORMAT_DEFAULT; + +/* GrB objects */ +extern GrB_BinaryOp GrB_BAND_INT8; +extern GrB_BinaryOp GrB_BAND_INT16; +extern GrB_BinaryOp GrB_BAND_INT32; +extern GrB_BinaryOp GrB_BAND_INT64; +extern GrB_BinaryOp GrB_BAND_UINT8; +extern GrB_BinaryOp GrB_BAND_UINT16; +extern GrB_BinaryOp GrB_BAND_UINT32; +extern GrB_BinaryOp GrB_BAND_UINT64; +extern GrB_BinaryOp GrB_BOR_INT8; +extern GrB_BinaryOp GrB_BOR_INT16; +extern GrB_BinaryOp GrB_BOR_INT32; +extern GrB_BinaryOp GrB_BOR_INT64; +extern GrB_BinaryOp GrB_BOR_UINT8; +extern GrB_BinaryOp GrB_BOR_UINT16; +extern GrB_BinaryOp GrB_BOR_UINT32; +extern GrB_BinaryOp GrB_BOR_UINT64; +extern GrB_BinaryOp GrB_BXNOR_INT8; +extern GrB_BinaryOp GrB_BXNOR_INT16; +extern GrB_BinaryOp GrB_BXNOR_INT32; +extern GrB_BinaryOp GrB_BXNOR_INT64; +extern GrB_BinaryOp GrB_BXNOR_UINT8; +extern GrB_BinaryOp GrB_BXNOR_UINT16; +extern GrB_BinaryOp GrB_BXNOR_UINT32; +extern GrB_BinaryOp GrB_BXNOR_UINT64; +extern GrB_BinaryOp GrB_BXOR_INT8; +extern GrB_BinaryOp GrB_BXOR_INT16; +extern GrB_BinaryOp GrB_BXOR_INT32; +extern GrB_BinaryOp GrB_BXOR_INT64; +extern GrB_BinaryOp GrB_BXOR_UINT8; +extern GrB_BinaryOp GrB_BXOR_UINT16; +extern GrB_BinaryOp GrB_BXOR_UINT32; +extern GrB_BinaryOp GrB_BXOR_UINT64; +extern GrB_BinaryOp GrB_DIV_BOOL; +extern GrB_BinaryOp GrB_DIV_FP32; +extern GrB_BinaryOp GrB_DIV_FP64; +extern GrB_BinaryOp GrB_DIV_INT8; +extern GrB_BinaryOp GrB_DIV_INT16; +extern GrB_BinaryOp GrB_DIV_INT32; +extern GrB_BinaryOp GrB_DIV_INT64; +extern GrB_BinaryOp GrB_DIV_UINT8; +extern GrB_BinaryOp GrB_DIV_UINT16; +extern GrB_BinaryOp GrB_DIV_UINT32; +extern GrB_BinaryOp GrB_DIV_UINT64; +extern GrB_BinaryOp GrB_EQ_BOOL; +extern GrB_BinaryOp GrB_EQ_FP32; +extern GrB_BinaryOp GrB_EQ_FP64; +extern GrB_BinaryOp GrB_EQ_INT8; +extern GrB_BinaryOp GrB_EQ_INT16; +extern GrB_BinaryOp GrB_EQ_INT32; +extern GrB_BinaryOp GrB_EQ_INT64; +extern GrB_BinaryOp GrB_EQ_UINT8; +extern GrB_BinaryOp GrB_EQ_UINT16; +extern GrB_BinaryOp GrB_EQ_UINT32; +extern GrB_BinaryOp GrB_EQ_UINT64; +extern GrB_BinaryOp GrB_FIRST_BOOL; +extern GrB_BinaryOp GrB_FIRST_FP32; +extern GrB_BinaryOp GrB_FIRST_FP64; +extern GrB_BinaryOp GrB_FIRST_INT8; +extern GrB_BinaryOp GrB_FIRST_INT16; +extern GrB_BinaryOp GrB_FIRST_INT32; +extern GrB_BinaryOp GrB_FIRST_INT64; +extern GrB_BinaryOp GrB_FIRST_UINT8; +extern GrB_BinaryOp GrB_FIRST_UINT16; +extern GrB_BinaryOp GrB_FIRST_UINT32; +extern GrB_BinaryOp GrB_FIRST_UINT64; +extern GrB_BinaryOp GrB_GE_BOOL; +extern GrB_BinaryOp GrB_GE_FP32; +extern GrB_BinaryOp GrB_GE_FP64; +extern GrB_BinaryOp GrB_GE_INT8; +extern GrB_BinaryOp GrB_GE_INT16; +extern GrB_BinaryOp GrB_GE_INT32; +extern GrB_BinaryOp GrB_GE_INT64; +extern GrB_BinaryOp GrB_GE_UINT8; +extern GrB_BinaryOp GrB_GE_UINT16; +extern GrB_BinaryOp GrB_GE_UINT32; +extern GrB_BinaryOp GrB_GE_UINT64; +extern GrB_BinaryOp GrB_GT_BOOL; +extern GrB_BinaryOp GrB_GT_FP32; +extern GrB_BinaryOp GrB_GT_FP64; +extern GrB_BinaryOp GrB_GT_INT8; +extern GrB_BinaryOp GrB_GT_INT16; +extern GrB_BinaryOp GrB_GT_INT32; +extern GrB_BinaryOp GrB_GT_INT64; +extern GrB_BinaryOp GrB_GT_UINT8; +extern GrB_BinaryOp GrB_GT_UINT16; +extern GrB_BinaryOp GrB_GT_UINT32; +extern GrB_BinaryOp GrB_GT_UINT64; +extern GrB_BinaryOp GrB_LAND; +extern GrB_BinaryOp GrB_LE_BOOL; +extern GrB_BinaryOp GrB_LE_FP32; +extern GrB_BinaryOp GrB_LE_FP64; +extern GrB_BinaryOp GrB_LE_INT8; +extern GrB_BinaryOp GrB_LE_INT16; +extern GrB_BinaryOp GrB_LE_INT32; +extern GrB_BinaryOp GrB_LE_INT64; +extern GrB_BinaryOp GrB_LE_UINT8; +extern GrB_BinaryOp GrB_LE_UINT16; +extern GrB_BinaryOp GrB_LE_UINT32; +extern GrB_BinaryOp GrB_LE_UINT64; +extern GrB_BinaryOp GrB_LOR; +extern GrB_BinaryOp GrB_LT_BOOL; +extern GrB_BinaryOp GrB_LT_FP32; +extern GrB_BinaryOp GrB_LT_FP64; +extern GrB_BinaryOp GrB_LT_INT8; +extern GrB_BinaryOp GrB_LT_INT16; +extern GrB_BinaryOp GrB_LT_INT32; +extern GrB_BinaryOp GrB_LT_INT64; +extern GrB_BinaryOp GrB_LT_UINT8; +extern GrB_BinaryOp GrB_LT_UINT16; +extern GrB_BinaryOp GrB_LT_UINT32; +extern GrB_BinaryOp GrB_LT_UINT64; +extern GrB_BinaryOp GrB_LXNOR; +extern GrB_BinaryOp GrB_LXOR; +extern GrB_BinaryOp GrB_MAX_BOOL; +extern GrB_BinaryOp GrB_MAX_FP32; +extern GrB_BinaryOp GrB_MAX_FP64; +extern GrB_BinaryOp GrB_MAX_INT8; +extern GrB_BinaryOp GrB_MAX_INT16; +extern GrB_BinaryOp GrB_MAX_INT32; +extern GrB_BinaryOp GrB_MAX_INT64; +extern GrB_BinaryOp GrB_MAX_UINT8; +extern GrB_BinaryOp GrB_MAX_UINT16; +extern GrB_BinaryOp GrB_MAX_UINT32; +extern GrB_BinaryOp GrB_MAX_UINT64; +extern GrB_BinaryOp GrB_MINUS_BOOL; +extern GrB_BinaryOp GrB_MINUS_FP32; +extern GrB_BinaryOp GrB_MINUS_FP64; +extern GrB_BinaryOp GrB_MINUS_INT8; +extern GrB_BinaryOp GrB_MINUS_INT16; +extern GrB_BinaryOp GrB_MINUS_INT32; +extern GrB_BinaryOp GrB_MINUS_INT64; +extern GrB_BinaryOp GrB_MINUS_UINT8; +extern GrB_BinaryOp GrB_MINUS_UINT16; +extern GrB_BinaryOp GrB_MINUS_UINT32; +extern GrB_BinaryOp GrB_MINUS_UINT64; +extern GrB_BinaryOp GrB_MIN_BOOL; +extern GrB_BinaryOp GrB_MIN_FP32; +extern GrB_BinaryOp GrB_MIN_FP64; +extern GrB_BinaryOp GrB_MIN_INT8; +extern GrB_BinaryOp GrB_MIN_INT16; +extern GrB_BinaryOp GrB_MIN_INT32; +extern GrB_BinaryOp GrB_MIN_INT64; +extern GrB_BinaryOp GrB_MIN_UINT8; +extern GrB_BinaryOp GrB_MIN_UINT16; +extern GrB_BinaryOp GrB_MIN_UINT32; +extern GrB_BinaryOp GrB_MIN_UINT64; +extern GrB_BinaryOp GrB_NE_BOOL; +extern GrB_BinaryOp GrB_NE_FP32; +extern GrB_BinaryOp GrB_NE_FP64; +extern GrB_BinaryOp GrB_NE_INT8; +extern GrB_BinaryOp GrB_NE_INT16; +extern GrB_BinaryOp GrB_NE_INT32; +extern GrB_BinaryOp GrB_NE_INT64; +extern GrB_BinaryOp GrB_NE_UINT8; +extern GrB_BinaryOp GrB_NE_UINT16; +extern GrB_BinaryOp GrB_NE_UINT32; +extern GrB_BinaryOp GrB_NE_UINT64; +extern GrB_BinaryOp GrB_ONEB_BOOL; +extern GrB_BinaryOp GrB_ONEB_FP32; +extern GrB_BinaryOp GrB_ONEB_FP64; +extern GrB_BinaryOp GrB_ONEB_INT8; +extern GrB_BinaryOp GrB_ONEB_INT16; +extern GrB_BinaryOp GrB_ONEB_INT32; +extern GrB_BinaryOp GrB_ONEB_INT64; +extern GrB_BinaryOp GrB_ONEB_UINT8; +extern GrB_BinaryOp GrB_ONEB_UINT16; +extern GrB_BinaryOp GrB_ONEB_UINT32; +extern GrB_BinaryOp GrB_ONEB_UINT64; +extern GrB_BinaryOp GrB_PLUS_BOOL; +extern GrB_BinaryOp GrB_PLUS_FP32; +extern GrB_BinaryOp GrB_PLUS_FP64; +extern GrB_BinaryOp GrB_PLUS_INT8; +extern GrB_BinaryOp GrB_PLUS_INT16; +extern GrB_BinaryOp GrB_PLUS_INT32; +extern GrB_BinaryOp GrB_PLUS_INT64; +extern GrB_BinaryOp GrB_PLUS_UINT8; +extern GrB_BinaryOp GrB_PLUS_UINT16; +extern GrB_BinaryOp GrB_PLUS_UINT32; +extern GrB_BinaryOp GrB_PLUS_UINT64; +extern GrB_BinaryOp GrB_SECOND_BOOL; +extern GrB_BinaryOp GrB_SECOND_FP32; +extern GrB_BinaryOp GrB_SECOND_FP64; +extern GrB_BinaryOp GrB_SECOND_INT8; +extern GrB_BinaryOp GrB_SECOND_INT16; +extern GrB_BinaryOp GrB_SECOND_INT32; +extern GrB_BinaryOp GrB_SECOND_INT64; +extern GrB_BinaryOp GrB_SECOND_UINT8; +extern GrB_BinaryOp GrB_SECOND_UINT16; +extern GrB_BinaryOp GrB_SECOND_UINT32; +extern GrB_BinaryOp GrB_SECOND_UINT64; +extern GrB_BinaryOp GrB_TIMES_BOOL; +extern GrB_BinaryOp GrB_TIMES_FP32; +extern GrB_BinaryOp GrB_TIMES_FP64; +extern GrB_BinaryOp GrB_TIMES_INT8; +extern GrB_BinaryOp GrB_TIMES_INT16; +extern GrB_BinaryOp GrB_TIMES_INT32; +extern GrB_BinaryOp GrB_TIMES_INT64; +extern GrB_BinaryOp GrB_TIMES_UINT8; +extern GrB_BinaryOp GrB_TIMES_UINT16; +extern GrB_BinaryOp GrB_TIMES_UINT32; +extern GrB_BinaryOp GrB_TIMES_UINT64; +extern GrB_Descriptor GrB_DESC_C; +extern GrB_Descriptor GrB_DESC_CT0; +extern GrB_Descriptor GrB_DESC_CT0T1; +extern GrB_Descriptor GrB_DESC_CT1; +extern GrB_Descriptor GrB_DESC_R; +extern GrB_Descriptor GrB_DESC_RC; +extern GrB_Descriptor GrB_DESC_RCT0; +extern GrB_Descriptor GrB_DESC_RCT0T1; +extern GrB_Descriptor GrB_DESC_RCT1; +extern GrB_Descriptor GrB_DESC_RS; +extern GrB_Descriptor GrB_DESC_RSC; +extern GrB_Descriptor GrB_DESC_RSCT0; +extern GrB_Descriptor GrB_DESC_RSCT0T1; +extern GrB_Descriptor GrB_DESC_RSCT1; +extern GrB_Descriptor GrB_DESC_RST0; +extern GrB_Descriptor GrB_DESC_RST0T1; +extern GrB_Descriptor GrB_DESC_RST1; +extern GrB_Descriptor GrB_DESC_RT0; +extern GrB_Descriptor GrB_DESC_RT0T1; +extern GrB_Descriptor GrB_DESC_RT1; +extern GrB_Descriptor GrB_DESC_S; +extern GrB_Descriptor GrB_DESC_SC; +extern GrB_Descriptor GrB_DESC_SCT0; +extern GrB_Descriptor GrB_DESC_SCT0T1; +extern GrB_Descriptor GrB_DESC_SCT1; +extern GrB_Descriptor GrB_DESC_ST0; +extern GrB_Descriptor GrB_DESC_ST0T1; +extern GrB_Descriptor GrB_DESC_ST1; +extern GrB_Descriptor GrB_DESC_T0; +extern GrB_Descriptor GrB_DESC_T0T1; +extern GrB_Descriptor GrB_DESC_T1; +extern GrB_IndexUnaryOp GrB_COLGT; +extern GrB_IndexUnaryOp GrB_COLINDEX_INT32; +extern GrB_IndexUnaryOp GrB_COLINDEX_INT64; +extern GrB_IndexUnaryOp GrB_COLLE; +extern GrB_IndexUnaryOp GrB_DIAG; +extern GrB_IndexUnaryOp GrB_DIAGINDEX_INT32; +extern GrB_IndexUnaryOp GrB_DIAGINDEX_INT64; +extern GrB_IndexUnaryOp GrB_OFFDIAG; +extern GrB_IndexUnaryOp GrB_ROWGT; +extern GrB_IndexUnaryOp GrB_ROWINDEX_INT32; +extern GrB_IndexUnaryOp GrB_ROWINDEX_INT64; +extern GrB_IndexUnaryOp GrB_ROWLE; +extern GrB_IndexUnaryOp GrB_TRIL; +extern GrB_IndexUnaryOp GrB_TRIU; +extern GrB_IndexUnaryOp GrB_VALUEEQ_BOOL; +extern GrB_IndexUnaryOp GrB_VALUEEQ_FP32; +extern GrB_IndexUnaryOp GrB_VALUEEQ_FP64; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT8; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT16; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT32; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT64; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT8; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT16; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT32; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT64; +extern GrB_IndexUnaryOp GrB_VALUEGE_BOOL; +extern GrB_IndexUnaryOp GrB_VALUEGE_FP32; +extern GrB_IndexUnaryOp GrB_VALUEGE_FP64; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT8; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT16; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT32; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT64; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT8; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT16; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT32; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT64; +extern GrB_IndexUnaryOp GrB_VALUEGT_BOOL; +extern GrB_IndexUnaryOp GrB_VALUEGT_FP32; +extern GrB_IndexUnaryOp GrB_VALUEGT_FP64; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT8; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT16; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT32; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT64; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT8; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT16; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT32; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT64; +extern GrB_IndexUnaryOp GrB_VALUELE_BOOL; +extern GrB_IndexUnaryOp GrB_VALUELE_FP32; +extern GrB_IndexUnaryOp GrB_VALUELE_FP64; +extern GrB_IndexUnaryOp GrB_VALUELE_INT8; +extern GrB_IndexUnaryOp GrB_VALUELE_INT16; +extern GrB_IndexUnaryOp GrB_VALUELE_INT32; +extern GrB_IndexUnaryOp GrB_VALUELE_INT64; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT8; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT16; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT32; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT64; +extern GrB_IndexUnaryOp GrB_VALUELT_BOOL; +extern GrB_IndexUnaryOp GrB_VALUELT_FP32; +extern GrB_IndexUnaryOp GrB_VALUELT_FP64; +extern GrB_IndexUnaryOp GrB_VALUELT_INT8; +extern GrB_IndexUnaryOp GrB_VALUELT_INT16; +extern GrB_IndexUnaryOp GrB_VALUELT_INT32; +extern GrB_IndexUnaryOp GrB_VALUELT_INT64; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT8; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT16; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT32; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT64; +extern GrB_IndexUnaryOp GrB_VALUENE_BOOL; +extern GrB_IndexUnaryOp GrB_VALUENE_FP32; +extern GrB_IndexUnaryOp GrB_VALUENE_FP64; +extern GrB_IndexUnaryOp GrB_VALUENE_INT8; +extern GrB_IndexUnaryOp GrB_VALUENE_INT16; +extern GrB_IndexUnaryOp GrB_VALUENE_INT32; +extern GrB_IndexUnaryOp GrB_VALUENE_INT64; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT8; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT16; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT32; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT64; +extern GrB_Monoid GrB_LAND_MONOID_BOOL; +extern GrB_Monoid GrB_LOR_MONOID_BOOL; +extern GrB_Monoid GrB_LXNOR_MONOID_BOOL; +extern GrB_Monoid GrB_LXOR_MONOID_BOOL; +extern GrB_Monoid GrB_MAX_MONOID_FP32; +extern GrB_Monoid GrB_MAX_MONOID_FP64; +extern GrB_Monoid GrB_MAX_MONOID_INT8; +extern GrB_Monoid GrB_MAX_MONOID_INT16; +extern GrB_Monoid GrB_MAX_MONOID_INT32; +extern GrB_Monoid GrB_MAX_MONOID_INT64; +extern GrB_Monoid GrB_MAX_MONOID_UINT8; +extern GrB_Monoid GrB_MAX_MONOID_UINT16; +extern GrB_Monoid GrB_MAX_MONOID_UINT32; +extern GrB_Monoid GrB_MAX_MONOID_UINT64; +extern GrB_Monoid GrB_MIN_MONOID_FP32; +extern GrB_Monoid GrB_MIN_MONOID_FP64; +extern GrB_Monoid GrB_MIN_MONOID_INT8; +extern GrB_Monoid GrB_MIN_MONOID_INT16; +extern GrB_Monoid GrB_MIN_MONOID_INT32; +extern GrB_Monoid GrB_MIN_MONOID_INT64; +extern GrB_Monoid GrB_MIN_MONOID_UINT8; +extern GrB_Monoid GrB_MIN_MONOID_UINT16; +extern GrB_Monoid GrB_MIN_MONOID_UINT32; +extern GrB_Monoid GrB_MIN_MONOID_UINT64; +extern GrB_Monoid GrB_PLUS_MONOID_FP32; +extern GrB_Monoid GrB_PLUS_MONOID_FP64; +extern GrB_Monoid GrB_PLUS_MONOID_INT8; +extern GrB_Monoid GrB_PLUS_MONOID_INT16; +extern GrB_Monoid GrB_PLUS_MONOID_INT32; +extern GrB_Monoid GrB_PLUS_MONOID_INT64; +extern GrB_Monoid GrB_PLUS_MONOID_UINT8; +extern GrB_Monoid GrB_PLUS_MONOID_UINT16; +extern GrB_Monoid GrB_PLUS_MONOID_UINT32; +extern GrB_Monoid GrB_PLUS_MONOID_UINT64; +extern GrB_Monoid GrB_TIMES_MONOID_FP32; +extern GrB_Monoid GrB_TIMES_MONOID_FP64; +extern GrB_Monoid GrB_TIMES_MONOID_INT8; +extern GrB_Monoid GrB_TIMES_MONOID_INT16; +extern GrB_Monoid GrB_TIMES_MONOID_INT32; +extern GrB_Monoid GrB_TIMES_MONOID_INT64; +extern GrB_Monoid GrB_TIMES_MONOID_UINT8; +extern GrB_Monoid GrB_TIMES_MONOID_UINT16; +extern GrB_Monoid GrB_TIMES_MONOID_UINT32; +extern GrB_Monoid GrB_TIMES_MONOID_UINT64; +extern GrB_Semiring GrB_LAND_LOR_SEMIRING_BOOL; +extern GrB_Semiring GrB_LOR_LAND_SEMIRING_BOOL; +extern GrB_Semiring GrB_LXNOR_LOR_SEMIRING_BOOL; +extern GrB_Semiring GrB_LXOR_LAND_SEMIRING_BOOL; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT64; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP32; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP64; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT8; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT16; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT32; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT64; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT8; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT16; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT32; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT64; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP32; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP64; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT8; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT16; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT32; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT64; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT8; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT16; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT32; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT64; +extern GrB_Type GrB_BOOL; +extern GrB_Type GrB_FP32; +extern GrB_Type GrB_FP64; +extern GrB_Type GrB_INT8; +extern GrB_Type GrB_INT16; +extern GrB_Type GrB_INT32; +extern GrB_Type GrB_INT64; +extern GrB_Type GrB_UINT8; +extern GrB_Type GrB_UINT16; +extern GrB_Type GrB_UINT32; +extern GrB_Type GrB_UINT64; +extern GrB_UnaryOp GrB_ABS_BOOL; +extern GrB_UnaryOp GrB_ABS_FP32; +extern GrB_UnaryOp GrB_ABS_FP64; +extern GrB_UnaryOp GrB_ABS_INT8; +extern GrB_UnaryOp GrB_ABS_INT16; +extern GrB_UnaryOp GrB_ABS_INT32; +extern GrB_UnaryOp GrB_ABS_INT64; +extern GrB_UnaryOp GrB_ABS_UINT8; +extern GrB_UnaryOp GrB_ABS_UINT16; +extern GrB_UnaryOp GrB_ABS_UINT32; +extern GrB_UnaryOp GrB_ABS_UINT64; +extern GrB_UnaryOp GrB_AINV_BOOL; +extern GrB_UnaryOp GrB_AINV_FP32; +extern GrB_UnaryOp GrB_AINV_FP64; +extern GrB_UnaryOp GrB_AINV_INT8; +extern GrB_UnaryOp GrB_AINV_INT16; +extern GrB_UnaryOp GrB_AINV_INT32; +extern GrB_UnaryOp GrB_AINV_INT64; +extern GrB_UnaryOp GrB_AINV_UINT8; +extern GrB_UnaryOp GrB_AINV_UINT16; +extern GrB_UnaryOp GrB_AINV_UINT32; +extern GrB_UnaryOp GrB_AINV_UINT64; +extern GrB_UnaryOp GrB_BNOT_INT8; +extern GrB_UnaryOp GrB_BNOT_INT16; +extern GrB_UnaryOp GrB_BNOT_INT32; +extern GrB_UnaryOp GrB_BNOT_INT64; +extern GrB_UnaryOp GrB_BNOT_UINT8; +extern GrB_UnaryOp GrB_BNOT_UINT16; +extern GrB_UnaryOp GrB_BNOT_UINT32; +extern GrB_UnaryOp GrB_BNOT_UINT64; +extern GrB_UnaryOp GrB_IDENTITY_BOOL; +extern GrB_UnaryOp GrB_IDENTITY_FP32; +extern GrB_UnaryOp GrB_IDENTITY_FP64; +extern GrB_UnaryOp GrB_IDENTITY_INT8; +extern GrB_UnaryOp GrB_IDENTITY_INT16; +extern GrB_UnaryOp GrB_IDENTITY_INT32; +extern GrB_UnaryOp GrB_IDENTITY_INT64; +extern GrB_UnaryOp GrB_IDENTITY_UINT8; +extern GrB_UnaryOp GrB_IDENTITY_UINT16; +extern GrB_UnaryOp GrB_IDENTITY_UINT32; +extern GrB_UnaryOp GrB_IDENTITY_UINT64; +extern GrB_UnaryOp GrB_LNOT; +extern GrB_UnaryOp GrB_MINV_BOOL; +extern GrB_UnaryOp GrB_MINV_FP32; +extern GrB_UnaryOp GrB_MINV_FP64; +extern GrB_UnaryOp GrB_MINV_INT8; +extern GrB_UnaryOp GrB_MINV_INT16; +extern GrB_UnaryOp GrB_MINV_INT32; +extern GrB_UnaryOp GrB_MINV_INT64; +extern GrB_UnaryOp GrB_MINV_UINT8; +extern GrB_UnaryOp GrB_MINV_UINT16; +extern GrB_UnaryOp GrB_MINV_UINT32; +extern GrB_UnaryOp GrB_MINV_UINT64; + +/* GrB objects (extended) */ +extern GrB_BinaryOp GxB_ANY_BOOL; +extern GrB_BinaryOp GxB_ANY_FC32; +extern GrB_BinaryOp GxB_ANY_FC64; +extern GrB_BinaryOp GxB_ANY_FP32; +extern GrB_BinaryOp GxB_ANY_FP64; +extern GrB_BinaryOp GxB_ANY_INT8; +extern GrB_BinaryOp GxB_ANY_INT16; +extern GrB_BinaryOp GxB_ANY_INT32; +extern GrB_BinaryOp GxB_ANY_INT64; +extern GrB_BinaryOp GxB_ANY_UINT8; +extern GrB_BinaryOp GxB_ANY_UINT16; +extern GrB_BinaryOp GxB_ANY_UINT32; +extern GrB_BinaryOp GxB_ANY_UINT64; +extern GrB_BinaryOp GxB_ATAN2_FP32; +extern GrB_BinaryOp GxB_ATAN2_FP64; +extern GrB_BinaryOp GxB_BCLR_INT8; +extern GrB_BinaryOp GxB_BCLR_INT16; +extern GrB_BinaryOp GxB_BCLR_INT32; +extern GrB_BinaryOp GxB_BCLR_INT64; +extern GrB_BinaryOp GxB_BCLR_UINT8; +extern GrB_BinaryOp GxB_BCLR_UINT16; +extern GrB_BinaryOp GxB_BCLR_UINT32; +extern GrB_BinaryOp GxB_BCLR_UINT64; +extern GrB_BinaryOp GxB_BGET_INT8; +extern GrB_BinaryOp GxB_BGET_INT16; +extern GrB_BinaryOp GxB_BGET_INT32; +extern GrB_BinaryOp GxB_BGET_INT64; +extern GrB_BinaryOp GxB_BGET_UINT8; +extern GrB_BinaryOp GxB_BGET_UINT16; +extern GrB_BinaryOp GxB_BGET_UINT32; +extern GrB_BinaryOp GxB_BGET_UINT64; +extern GrB_BinaryOp GxB_BSET_INT8; +extern GrB_BinaryOp GxB_BSET_INT16; +extern GrB_BinaryOp GxB_BSET_INT32; +extern GrB_BinaryOp GxB_BSET_INT64; +extern GrB_BinaryOp GxB_BSET_UINT8; +extern GrB_BinaryOp GxB_BSET_UINT16; +extern GrB_BinaryOp GxB_BSET_UINT32; +extern GrB_BinaryOp GxB_BSET_UINT64; +extern GrB_BinaryOp GxB_BSHIFT_INT8; +extern GrB_BinaryOp GxB_BSHIFT_INT16; +extern GrB_BinaryOp GxB_BSHIFT_INT32; +extern GrB_BinaryOp GxB_BSHIFT_INT64; +extern GrB_BinaryOp GxB_BSHIFT_UINT8; +extern GrB_BinaryOp GxB_BSHIFT_UINT16; +extern GrB_BinaryOp GxB_BSHIFT_UINT32; +extern GrB_BinaryOp GxB_BSHIFT_UINT64; +extern GrB_BinaryOp GxB_CMPLX_FP32; +extern GrB_BinaryOp GxB_CMPLX_FP64; +extern GrB_BinaryOp GxB_COPYSIGN_FP32; +extern GrB_BinaryOp GxB_COPYSIGN_FP64; +extern GrB_BinaryOp GxB_DIV_FC32; +extern GrB_BinaryOp GxB_DIV_FC64; +extern GrB_BinaryOp GxB_EQ_FC32; +extern GrB_BinaryOp GxB_EQ_FC64; +extern GrB_BinaryOp GxB_FIRSTI1_INT32; +extern GrB_BinaryOp GxB_FIRSTI1_INT64; +extern GrB_BinaryOp GxB_FIRSTI_INT32; +extern GrB_BinaryOp GxB_FIRSTI_INT64; +extern GrB_BinaryOp GxB_FIRSTJ1_INT32; +extern GrB_BinaryOp GxB_FIRSTJ1_INT64; +extern GrB_BinaryOp GxB_FIRSTJ_INT32; +extern GrB_BinaryOp GxB_FIRSTJ_INT64; +extern GrB_BinaryOp GxB_FIRST_FC32; +extern GrB_BinaryOp GxB_FIRST_FC64; +extern GrB_BinaryOp GxB_FMOD_FP32; +extern GrB_BinaryOp GxB_FMOD_FP64; +extern GrB_BinaryOp GxB_HYPOT_FP32; +extern GrB_BinaryOp GxB_HYPOT_FP64; +extern GrB_BinaryOp GxB_IGNORE_DUP; +extern GrB_BinaryOp GxB_ISEQ_BOOL; +extern GrB_BinaryOp GxB_ISEQ_FC32; +extern GrB_BinaryOp GxB_ISEQ_FC64; +extern GrB_BinaryOp GxB_ISEQ_FP32; +extern GrB_BinaryOp GxB_ISEQ_FP64; +extern GrB_BinaryOp GxB_ISEQ_INT8; +extern GrB_BinaryOp GxB_ISEQ_INT16; +extern GrB_BinaryOp GxB_ISEQ_INT32; +extern GrB_BinaryOp GxB_ISEQ_INT64; +extern GrB_BinaryOp GxB_ISEQ_UINT8; +extern GrB_BinaryOp GxB_ISEQ_UINT16; +extern GrB_BinaryOp GxB_ISEQ_UINT32; +extern GrB_BinaryOp GxB_ISEQ_UINT64; +extern GrB_BinaryOp GxB_ISGE_BOOL; +extern GrB_BinaryOp GxB_ISGE_FP32; +extern GrB_BinaryOp GxB_ISGE_FP64; +extern GrB_BinaryOp GxB_ISGE_INT8; +extern GrB_BinaryOp GxB_ISGE_INT16; +extern GrB_BinaryOp GxB_ISGE_INT32; +extern GrB_BinaryOp GxB_ISGE_INT64; +extern GrB_BinaryOp GxB_ISGE_UINT8; +extern GrB_BinaryOp GxB_ISGE_UINT16; +extern GrB_BinaryOp GxB_ISGE_UINT32; +extern GrB_BinaryOp GxB_ISGE_UINT64; +extern GrB_BinaryOp GxB_ISGT_BOOL; +extern GrB_BinaryOp GxB_ISGT_FP32; +extern GrB_BinaryOp GxB_ISGT_FP64; +extern GrB_BinaryOp GxB_ISGT_INT8; +extern GrB_BinaryOp GxB_ISGT_INT16; +extern GrB_BinaryOp GxB_ISGT_INT32; +extern GrB_BinaryOp GxB_ISGT_INT64; +extern GrB_BinaryOp GxB_ISGT_UINT8; +extern GrB_BinaryOp GxB_ISGT_UINT16; +extern GrB_BinaryOp GxB_ISGT_UINT32; +extern GrB_BinaryOp GxB_ISGT_UINT64; +extern GrB_BinaryOp GxB_ISLE_BOOL; +extern GrB_BinaryOp GxB_ISLE_FP32; +extern GrB_BinaryOp GxB_ISLE_FP64; +extern GrB_BinaryOp GxB_ISLE_INT8; +extern GrB_BinaryOp GxB_ISLE_INT16; +extern GrB_BinaryOp GxB_ISLE_INT32; +extern GrB_BinaryOp GxB_ISLE_INT64; +extern GrB_BinaryOp GxB_ISLE_UINT8; +extern GrB_BinaryOp GxB_ISLE_UINT16; +extern GrB_BinaryOp GxB_ISLE_UINT32; +extern GrB_BinaryOp GxB_ISLE_UINT64; +extern GrB_BinaryOp GxB_ISLT_BOOL; +extern GrB_BinaryOp GxB_ISLT_FP32; +extern GrB_BinaryOp GxB_ISLT_FP64; +extern GrB_BinaryOp GxB_ISLT_INT8; +extern GrB_BinaryOp GxB_ISLT_INT16; +extern GrB_BinaryOp GxB_ISLT_INT32; +extern GrB_BinaryOp GxB_ISLT_INT64; +extern GrB_BinaryOp GxB_ISLT_UINT8; +extern GrB_BinaryOp GxB_ISLT_UINT16; +extern GrB_BinaryOp GxB_ISLT_UINT32; +extern GrB_BinaryOp GxB_ISLT_UINT64; +extern GrB_BinaryOp GxB_ISNE_BOOL; +extern GrB_BinaryOp GxB_ISNE_FC32; +extern GrB_BinaryOp GxB_ISNE_FC64; +extern GrB_BinaryOp GxB_ISNE_FP32; +extern GrB_BinaryOp GxB_ISNE_FP64; +extern GrB_BinaryOp GxB_ISNE_INT8; +extern GrB_BinaryOp GxB_ISNE_INT16; +extern GrB_BinaryOp GxB_ISNE_INT32; +extern GrB_BinaryOp GxB_ISNE_INT64; +extern GrB_BinaryOp GxB_ISNE_UINT8; +extern GrB_BinaryOp GxB_ISNE_UINT16; +extern GrB_BinaryOp GxB_ISNE_UINT32; +extern GrB_BinaryOp GxB_ISNE_UINT64; +extern GrB_BinaryOp GxB_LAND_BOOL; +extern GrB_BinaryOp GxB_LAND_FP32; +extern GrB_BinaryOp GxB_LAND_FP64; +extern GrB_BinaryOp GxB_LAND_INT8; +extern GrB_BinaryOp GxB_LAND_INT16; +extern GrB_BinaryOp GxB_LAND_INT32; +extern GrB_BinaryOp GxB_LAND_INT64; +extern GrB_BinaryOp GxB_LAND_UINT8; +extern GrB_BinaryOp GxB_LAND_UINT16; +extern GrB_BinaryOp GxB_LAND_UINT32; +extern GrB_BinaryOp GxB_LAND_UINT64; +extern GrB_BinaryOp GxB_LDEXP_FP32; +extern GrB_BinaryOp GxB_LDEXP_FP64; +extern GrB_BinaryOp GxB_LOR_BOOL; +extern GrB_BinaryOp GxB_LOR_FP32; +extern GrB_BinaryOp GxB_LOR_FP64; +extern GrB_BinaryOp GxB_LOR_INT8; +extern GrB_BinaryOp GxB_LOR_INT16; +extern GrB_BinaryOp GxB_LOR_INT32; +extern GrB_BinaryOp GxB_LOR_INT64; +extern GrB_BinaryOp GxB_LOR_UINT8; +extern GrB_BinaryOp GxB_LOR_UINT16; +extern GrB_BinaryOp GxB_LOR_UINT32; +extern GrB_BinaryOp GxB_LOR_UINT64; +extern GrB_BinaryOp GxB_LXOR_BOOL; +extern GrB_BinaryOp GxB_LXOR_FP32; +extern GrB_BinaryOp GxB_LXOR_FP64; +extern GrB_BinaryOp GxB_LXOR_INT8; +extern GrB_BinaryOp GxB_LXOR_INT16; +extern GrB_BinaryOp GxB_LXOR_INT32; +extern GrB_BinaryOp GxB_LXOR_INT64; +extern GrB_BinaryOp GxB_LXOR_UINT8; +extern GrB_BinaryOp GxB_LXOR_UINT16; +extern GrB_BinaryOp GxB_LXOR_UINT32; +extern GrB_BinaryOp GxB_LXOR_UINT64; +extern GrB_BinaryOp GxB_MINUS_FC32; +extern GrB_BinaryOp GxB_MINUS_FC64; +extern GrB_BinaryOp GxB_NE_FC32; +extern GrB_BinaryOp GxB_NE_FC64; +extern GrB_BinaryOp GxB_ONEB_FC32; +extern GrB_BinaryOp GxB_ONEB_FC64; +extern GrB_BinaryOp GxB_PAIR_BOOL; +extern GrB_BinaryOp GxB_PAIR_FC32; +extern GrB_BinaryOp GxB_PAIR_FC64; +extern GrB_BinaryOp GxB_PAIR_FP32; +extern GrB_BinaryOp GxB_PAIR_FP64; +extern GrB_BinaryOp GxB_PAIR_INT8; +extern GrB_BinaryOp GxB_PAIR_INT16; +extern GrB_BinaryOp GxB_PAIR_INT32; +extern GrB_BinaryOp GxB_PAIR_INT64; +extern GrB_BinaryOp GxB_PAIR_UINT8; +extern GrB_BinaryOp GxB_PAIR_UINT16; +extern GrB_BinaryOp GxB_PAIR_UINT32; +extern GrB_BinaryOp GxB_PAIR_UINT64; +extern GrB_BinaryOp GxB_PLUS_FC32; +extern GrB_BinaryOp GxB_PLUS_FC64; +extern GrB_BinaryOp GxB_POW_BOOL; +extern GrB_BinaryOp GxB_POW_FC32; +extern GrB_BinaryOp GxB_POW_FC64; +extern GrB_BinaryOp GxB_POW_FP32; +extern GrB_BinaryOp GxB_POW_FP64; +extern GrB_BinaryOp GxB_POW_INT8; +extern GrB_BinaryOp GxB_POW_INT16; +extern GrB_BinaryOp GxB_POW_INT32; +extern GrB_BinaryOp GxB_POW_INT64; +extern GrB_BinaryOp GxB_POW_UINT8; +extern GrB_BinaryOp GxB_POW_UINT16; +extern GrB_BinaryOp GxB_POW_UINT32; +extern GrB_BinaryOp GxB_POW_UINT64; +extern GrB_BinaryOp GxB_RDIV_BOOL; +extern GrB_BinaryOp GxB_RDIV_FC32; +extern GrB_BinaryOp GxB_RDIV_FC64; +extern GrB_BinaryOp GxB_RDIV_FP32; +extern GrB_BinaryOp GxB_RDIV_FP64; +extern GrB_BinaryOp GxB_RDIV_INT8; +extern GrB_BinaryOp GxB_RDIV_INT16; +extern GrB_BinaryOp GxB_RDIV_INT32; +extern GrB_BinaryOp GxB_RDIV_INT64; +extern GrB_BinaryOp GxB_RDIV_UINT8; +extern GrB_BinaryOp GxB_RDIV_UINT16; +extern GrB_BinaryOp GxB_RDIV_UINT32; +extern GrB_BinaryOp GxB_RDIV_UINT64; +extern GrB_BinaryOp GxB_REMAINDER_FP32; +extern GrB_BinaryOp GxB_REMAINDER_FP64; +extern GrB_BinaryOp GxB_RMINUS_BOOL; +extern GrB_BinaryOp GxB_RMINUS_FC32; +extern GrB_BinaryOp GxB_RMINUS_FC64; +extern GrB_BinaryOp GxB_RMINUS_FP32; +extern GrB_BinaryOp GxB_RMINUS_FP64; +extern GrB_BinaryOp GxB_RMINUS_INT8; +extern GrB_BinaryOp GxB_RMINUS_INT16; +extern GrB_BinaryOp GxB_RMINUS_INT32; +extern GrB_BinaryOp GxB_RMINUS_INT64; +extern GrB_BinaryOp GxB_RMINUS_UINT8; +extern GrB_BinaryOp GxB_RMINUS_UINT16; +extern GrB_BinaryOp GxB_RMINUS_UINT32; +extern GrB_BinaryOp GxB_RMINUS_UINT64; +extern GrB_BinaryOp GxB_SECONDI1_INT32; +extern GrB_BinaryOp GxB_SECONDI1_INT64; +extern GrB_BinaryOp GxB_SECONDI_INT32; +extern GrB_BinaryOp GxB_SECONDI_INT64; +extern GrB_BinaryOp GxB_SECONDJ1_INT32; +extern GrB_BinaryOp GxB_SECONDJ1_INT64; +extern GrB_BinaryOp GxB_SECONDJ_INT32; +extern GrB_BinaryOp GxB_SECONDJ_INT64; +extern GrB_BinaryOp GxB_SECOND_FC32; +extern GrB_BinaryOp GxB_SECOND_FC64; +extern GrB_BinaryOp GxB_TIMES_FC32; +extern GrB_BinaryOp GxB_TIMES_FC64; +extern GrB_IndexUnaryOp GxB_VALUEEQ_FC32; +extern GrB_IndexUnaryOp GxB_VALUEEQ_FC64; +extern GrB_IndexUnaryOp GxB_VALUENE_FC32; +extern GrB_IndexUnaryOp GxB_VALUENE_FC64; +extern GrB_Monoid GxB_ANY_BOOL_MONOID; +extern GrB_Monoid GxB_ANY_FC32_MONOID; +extern GrB_Monoid GxB_ANY_FC64_MONOID; +extern GrB_Monoid GxB_ANY_FP32_MONOID; +extern GrB_Monoid GxB_ANY_FP64_MONOID; +extern GrB_Monoid GxB_ANY_INT8_MONOID; +extern GrB_Monoid GxB_ANY_INT16_MONOID; +extern GrB_Monoid GxB_ANY_INT32_MONOID; +extern GrB_Monoid GxB_ANY_INT64_MONOID; +extern GrB_Monoid GxB_ANY_UINT8_MONOID; +extern GrB_Monoid GxB_ANY_UINT16_MONOID; +extern GrB_Monoid GxB_ANY_UINT32_MONOID; +extern GrB_Monoid GxB_ANY_UINT64_MONOID; +extern GrB_Monoid GxB_BAND_UINT8_MONOID; +extern GrB_Monoid GxB_BAND_UINT16_MONOID; +extern GrB_Monoid GxB_BAND_UINT32_MONOID; +extern GrB_Monoid GxB_BAND_UINT64_MONOID; +extern GrB_Monoid GxB_BOR_UINT8_MONOID; +extern GrB_Monoid GxB_BOR_UINT16_MONOID; +extern GrB_Monoid GxB_BOR_UINT32_MONOID; +extern GrB_Monoid GxB_BOR_UINT64_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT8_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT16_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT32_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT64_MONOID; +extern GrB_Monoid GxB_BXOR_UINT8_MONOID; +extern GrB_Monoid GxB_BXOR_UINT16_MONOID; +extern GrB_Monoid GxB_BXOR_UINT32_MONOID; +extern GrB_Monoid GxB_BXOR_UINT64_MONOID; +extern GrB_Monoid GxB_EQ_BOOL_MONOID; +extern GrB_Monoid GxB_PLUS_FC32_MONOID; +extern GrB_Monoid GxB_PLUS_FC64_MONOID; +extern GrB_Monoid GxB_TIMES_FC32_MONOID; +extern GrB_Monoid GxB_TIMES_FC64_MONOID; +extern GrB_Semiring GxB_ANY_DIV_FC32; +extern GrB_Semiring GxB_ANY_DIV_FC64; +extern GrB_Semiring GxB_ANY_DIV_FP32; +extern GrB_Semiring GxB_ANY_DIV_FP64; +extern GrB_Semiring GxB_ANY_DIV_INT8; +extern GrB_Semiring GxB_ANY_DIV_INT16; +extern GrB_Semiring GxB_ANY_DIV_INT32; +extern GrB_Semiring GxB_ANY_DIV_INT64; +extern GrB_Semiring GxB_ANY_DIV_UINT8; +extern GrB_Semiring GxB_ANY_DIV_UINT16; +extern GrB_Semiring GxB_ANY_DIV_UINT32; +extern GrB_Semiring GxB_ANY_DIV_UINT64; +extern GrB_Semiring GxB_ANY_EQ_BOOL; +extern GrB_Semiring GxB_ANY_EQ_FP32; +extern GrB_Semiring GxB_ANY_EQ_FP64; +extern GrB_Semiring GxB_ANY_EQ_INT8; +extern GrB_Semiring GxB_ANY_EQ_INT16; +extern GrB_Semiring GxB_ANY_EQ_INT32; +extern GrB_Semiring GxB_ANY_EQ_INT64; +extern GrB_Semiring GxB_ANY_EQ_UINT8; +extern GrB_Semiring GxB_ANY_EQ_UINT16; +extern GrB_Semiring GxB_ANY_EQ_UINT32; +extern GrB_Semiring GxB_ANY_EQ_UINT64; +extern GrB_Semiring GxB_ANY_FIRSTI1_INT32; +extern GrB_Semiring GxB_ANY_FIRSTI1_INT64; +extern GrB_Semiring GxB_ANY_FIRSTI_INT32; +extern GrB_Semiring GxB_ANY_FIRSTI_INT64; +extern GrB_Semiring GxB_ANY_FIRSTJ1_INT32; +extern GrB_Semiring GxB_ANY_FIRSTJ1_INT64; +extern GrB_Semiring GxB_ANY_FIRSTJ_INT32; +extern GrB_Semiring GxB_ANY_FIRSTJ_INT64; +extern GrB_Semiring GxB_ANY_FIRST_BOOL; +extern GrB_Semiring GxB_ANY_FIRST_FC32; +extern GrB_Semiring GxB_ANY_FIRST_FC64; +extern GrB_Semiring GxB_ANY_FIRST_FP32; +extern GrB_Semiring GxB_ANY_FIRST_FP64; +extern GrB_Semiring GxB_ANY_FIRST_INT8; +extern GrB_Semiring GxB_ANY_FIRST_INT16; +extern GrB_Semiring GxB_ANY_FIRST_INT32; +extern GrB_Semiring GxB_ANY_FIRST_INT64; +extern GrB_Semiring GxB_ANY_FIRST_UINT8; +extern GrB_Semiring GxB_ANY_FIRST_UINT16; +extern GrB_Semiring GxB_ANY_FIRST_UINT32; +extern GrB_Semiring GxB_ANY_FIRST_UINT64; +extern GrB_Semiring GxB_ANY_GE_BOOL; +extern GrB_Semiring GxB_ANY_GE_FP32; +extern GrB_Semiring GxB_ANY_GE_FP64; +extern GrB_Semiring GxB_ANY_GE_INT8; +extern GrB_Semiring GxB_ANY_GE_INT16; +extern GrB_Semiring GxB_ANY_GE_INT32; +extern GrB_Semiring GxB_ANY_GE_INT64; +extern GrB_Semiring GxB_ANY_GE_UINT8; +extern GrB_Semiring GxB_ANY_GE_UINT16; +extern GrB_Semiring GxB_ANY_GE_UINT32; +extern GrB_Semiring GxB_ANY_GE_UINT64; +extern GrB_Semiring GxB_ANY_GT_BOOL; +extern GrB_Semiring GxB_ANY_GT_FP32; +extern GrB_Semiring GxB_ANY_GT_FP64; +extern GrB_Semiring GxB_ANY_GT_INT8; +extern GrB_Semiring GxB_ANY_GT_INT16; +extern GrB_Semiring GxB_ANY_GT_INT32; +extern GrB_Semiring GxB_ANY_GT_INT64; +extern GrB_Semiring GxB_ANY_GT_UINT8; +extern GrB_Semiring GxB_ANY_GT_UINT16; +extern GrB_Semiring GxB_ANY_GT_UINT32; +extern GrB_Semiring GxB_ANY_GT_UINT64; +extern GrB_Semiring GxB_ANY_ISEQ_FP32; +extern GrB_Semiring GxB_ANY_ISEQ_FP64; +extern GrB_Semiring GxB_ANY_ISEQ_INT8; +extern GrB_Semiring GxB_ANY_ISEQ_INT16; +extern GrB_Semiring GxB_ANY_ISEQ_INT32; +extern GrB_Semiring GxB_ANY_ISEQ_INT64; +extern GrB_Semiring GxB_ANY_ISEQ_UINT8; +extern GrB_Semiring GxB_ANY_ISEQ_UINT16; +extern GrB_Semiring GxB_ANY_ISEQ_UINT32; +extern GrB_Semiring GxB_ANY_ISEQ_UINT64; +extern GrB_Semiring GxB_ANY_ISGE_FP32; +extern GrB_Semiring GxB_ANY_ISGE_FP64; +extern GrB_Semiring GxB_ANY_ISGE_INT8; +extern GrB_Semiring GxB_ANY_ISGE_INT16; +extern GrB_Semiring GxB_ANY_ISGE_INT32; +extern GrB_Semiring GxB_ANY_ISGE_INT64; +extern GrB_Semiring GxB_ANY_ISGE_UINT8; +extern GrB_Semiring GxB_ANY_ISGE_UINT16; +extern GrB_Semiring GxB_ANY_ISGE_UINT32; +extern GrB_Semiring GxB_ANY_ISGE_UINT64; +extern GrB_Semiring GxB_ANY_ISGT_FP32; +extern GrB_Semiring GxB_ANY_ISGT_FP64; +extern GrB_Semiring GxB_ANY_ISGT_INT8; +extern GrB_Semiring GxB_ANY_ISGT_INT16; +extern GrB_Semiring GxB_ANY_ISGT_INT32; +extern GrB_Semiring GxB_ANY_ISGT_INT64; +extern GrB_Semiring GxB_ANY_ISGT_UINT8; +extern GrB_Semiring GxB_ANY_ISGT_UINT16; +extern GrB_Semiring GxB_ANY_ISGT_UINT32; +extern GrB_Semiring GxB_ANY_ISGT_UINT64; +extern GrB_Semiring GxB_ANY_ISLE_FP32; +extern GrB_Semiring GxB_ANY_ISLE_FP64; +extern GrB_Semiring GxB_ANY_ISLE_INT8; +extern GrB_Semiring GxB_ANY_ISLE_INT16; +extern GrB_Semiring GxB_ANY_ISLE_INT32; +extern GrB_Semiring GxB_ANY_ISLE_INT64; +extern GrB_Semiring GxB_ANY_ISLE_UINT8; +extern GrB_Semiring GxB_ANY_ISLE_UINT16; +extern GrB_Semiring GxB_ANY_ISLE_UINT32; +extern GrB_Semiring GxB_ANY_ISLE_UINT64; +extern GrB_Semiring GxB_ANY_ISLT_FP32; +extern GrB_Semiring GxB_ANY_ISLT_FP64; +extern GrB_Semiring GxB_ANY_ISLT_INT8; +extern GrB_Semiring GxB_ANY_ISLT_INT16; +extern GrB_Semiring GxB_ANY_ISLT_INT32; +extern GrB_Semiring GxB_ANY_ISLT_INT64; +extern GrB_Semiring GxB_ANY_ISLT_UINT8; +extern GrB_Semiring GxB_ANY_ISLT_UINT16; +extern GrB_Semiring GxB_ANY_ISLT_UINT32; +extern GrB_Semiring GxB_ANY_ISLT_UINT64; +extern GrB_Semiring GxB_ANY_ISNE_FP32; +extern GrB_Semiring GxB_ANY_ISNE_FP64; +extern GrB_Semiring GxB_ANY_ISNE_INT8; +extern GrB_Semiring GxB_ANY_ISNE_INT16; +extern GrB_Semiring GxB_ANY_ISNE_INT32; +extern GrB_Semiring GxB_ANY_ISNE_INT64; +extern GrB_Semiring GxB_ANY_ISNE_UINT8; +extern GrB_Semiring GxB_ANY_ISNE_UINT16; +extern GrB_Semiring GxB_ANY_ISNE_UINT32; +extern GrB_Semiring GxB_ANY_ISNE_UINT64; +extern GrB_Semiring GxB_ANY_LAND_BOOL; +extern GrB_Semiring GxB_ANY_LAND_FP32; +extern GrB_Semiring GxB_ANY_LAND_FP64; +extern GrB_Semiring GxB_ANY_LAND_INT8; +extern GrB_Semiring GxB_ANY_LAND_INT16; +extern GrB_Semiring GxB_ANY_LAND_INT32; +extern GrB_Semiring GxB_ANY_LAND_INT64; +extern GrB_Semiring GxB_ANY_LAND_UINT8; +extern GrB_Semiring GxB_ANY_LAND_UINT16; +extern GrB_Semiring GxB_ANY_LAND_UINT32; +extern GrB_Semiring GxB_ANY_LAND_UINT64; +extern GrB_Semiring GxB_ANY_LE_BOOL; +extern GrB_Semiring GxB_ANY_LE_FP32; +extern GrB_Semiring GxB_ANY_LE_FP64; +extern GrB_Semiring GxB_ANY_LE_INT8; +extern GrB_Semiring GxB_ANY_LE_INT16; +extern GrB_Semiring GxB_ANY_LE_INT32; +extern GrB_Semiring GxB_ANY_LE_INT64; +extern GrB_Semiring GxB_ANY_LE_UINT8; +extern GrB_Semiring GxB_ANY_LE_UINT16; +extern GrB_Semiring GxB_ANY_LE_UINT32; +extern GrB_Semiring GxB_ANY_LE_UINT64; +extern GrB_Semiring GxB_ANY_LOR_BOOL; +extern GrB_Semiring GxB_ANY_LOR_FP32; +extern GrB_Semiring GxB_ANY_LOR_FP64; +extern GrB_Semiring GxB_ANY_LOR_INT8; +extern GrB_Semiring GxB_ANY_LOR_INT16; +extern GrB_Semiring GxB_ANY_LOR_INT32; +extern GrB_Semiring GxB_ANY_LOR_INT64; +extern GrB_Semiring GxB_ANY_LOR_UINT8; +extern GrB_Semiring GxB_ANY_LOR_UINT16; +extern GrB_Semiring GxB_ANY_LOR_UINT32; +extern GrB_Semiring GxB_ANY_LOR_UINT64; +extern GrB_Semiring GxB_ANY_LT_BOOL; +extern GrB_Semiring GxB_ANY_LT_FP32; +extern GrB_Semiring GxB_ANY_LT_FP64; +extern GrB_Semiring GxB_ANY_LT_INT8; +extern GrB_Semiring GxB_ANY_LT_INT16; +extern GrB_Semiring GxB_ANY_LT_INT32; +extern GrB_Semiring GxB_ANY_LT_INT64; +extern GrB_Semiring GxB_ANY_LT_UINT8; +extern GrB_Semiring GxB_ANY_LT_UINT16; +extern GrB_Semiring GxB_ANY_LT_UINT32; +extern GrB_Semiring GxB_ANY_LT_UINT64; +extern GrB_Semiring GxB_ANY_LXOR_BOOL; +extern GrB_Semiring GxB_ANY_LXOR_FP32; +extern GrB_Semiring GxB_ANY_LXOR_FP64; +extern GrB_Semiring GxB_ANY_LXOR_INT8; +extern GrB_Semiring GxB_ANY_LXOR_INT16; +extern GrB_Semiring GxB_ANY_LXOR_INT32; +extern GrB_Semiring GxB_ANY_LXOR_INT64; +extern GrB_Semiring GxB_ANY_LXOR_UINT8; +extern GrB_Semiring GxB_ANY_LXOR_UINT16; +extern GrB_Semiring GxB_ANY_LXOR_UINT32; +extern GrB_Semiring GxB_ANY_LXOR_UINT64; +extern GrB_Semiring GxB_ANY_MAX_FP32; +extern GrB_Semiring GxB_ANY_MAX_FP64; +extern GrB_Semiring GxB_ANY_MAX_INT8; +extern GrB_Semiring GxB_ANY_MAX_INT16; +extern GrB_Semiring GxB_ANY_MAX_INT32; +extern GrB_Semiring GxB_ANY_MAX_INT64; +extern GrB_Semiring GxB_ANY_MAX_UINT8; +extern GrB_Semiring GxB_ANY_MAX_UINT16; +extern GrB_Semiring GxB_ANY_MAX_UINT32; +extern GrB_Semiring GxB_ANY_MAX_UINT64; +extern GrB_Semiring GxB_ANY_MINUS_FC32; +extern GrB_Semiring GxB_ANY_MINUS_FC64; +extern GrB_Semiring GxB_ANY_MINUS_FP32; +extern GrB_Semiring GxB_ANY_MINUS_FP64; +extern GrB_Semiring GxB_ANY_MINUS_INT8; +extern GrB_Semiring GxB_ANY_MINUS_INT16; +extern GrB_Semiring GxB_ANY_MINUS_INT32; +extern GrB_Semiring GxB_ANY_MINUS_INT64; +extern GrB_Semiring GxB_ANY_MINUS_UINT8; +extern GrB_Semiring GxB_ANY_MINUS_UINT16; +extern GrB_Semiring GxB_ANY_MINUS_UINT32; +extern GrB_Semiring GxB_ANY_MINUS_UINT64; +extern GrB_Semiring GxB_ANY_MIN_FP32; +extern GrB_Semiring GxB_ANY_MIN_FP64; +extern GrB_Semiring GxB_ANY_MIN_INT8; +extern GrB_Semiring GxB_ANY_MIN_INT16; +extern GrB_Semiring GxB_ANY_MIN_INT32; +extern GrB_Semiring GxB_ANY_MIN_INT64; +extern GrB_Semiring GxB_ANY_MIN_UINT8; +extern GrB_Semiring GxB_ANY_MIN_UINT16; +extern GrB_Semiring GxB_ANY_MIN_UINT32; +extern GrB_Semiring GxB_ANY_MIN_UINT64; +extern GrB_Semiring GxB_ANY_NE_FP32; +extern GrB_Semiring GxB_ANY_NE_FP64; +extern GrB_Semiring GxB_ANY_NE_INT8; +extern GrB_Semiring GxB_ANY_NE_INT16; +extern GrB_Semiring GxB_ANY_NE_INT32; +extern GrB_Semiring GxB_ANY_NE_INT64; +extern GrB_Semiring GxB_ANY_NE_UINT8; +extern GrB_Semiring GxB_ANY_NE_UINT16; +extern GrB_Semiring GxB_ANY_NE_UINT32; +extern GrB_Semiring GxB_ANY_NE_UINT64; +extern GrB_Semiring GxB_ANY_PAIR_BOOL; +extern GrB_Semiring GxB_ANY_PAIR_FC32; +extern GrB_Semiring GxB_ANY_PAIR_FC64; +extern GrB_Semiring GxB_ANY_PAIR_FP32; +extern GrB_Semiring GxB_ANY_PAIR_FP64; +extern GrB_Semiring GxB_ANY_PAIR_INT8; +extern GrB_Semiring GxB_ANY_PAIR_INT16; +extern GrB_Semiring GxB_ANY_PAIR_INT32; +extern GrB_Semiring GxB_ANY_PAIR_INT64; +extern GrB_Semiring GxB_ANY_PAIR_UINT8; +extern GrB_Semiring GxB_ANY_PAIR_UINT16; +extern GrB_Semiring GxB_ANY_PAIR_UINT32; +extern GrB_Semiring GxB_ANY_PAIR_UINT64; +extern GrB_Semiring GxB_ANY_PLUS_FC32; +extern GrB_Semiring GxB_ANY_PLUS_FC64; +extern GrB_Semiring GxB_ANY_PLUS_FP32; +extern GrB_Semiring GxB_ANY_PLUS_FP64; +extern GrB_Semiring GxB_ANY_PLUS_INT8; +extern GrB_Semiring GxB_ANY_PLUS_INT16; +extern GrB_Semiring GxB_ANY_PLUS_INT32; +extern GrB_Semiring GxB_ANY_PLUS_INT64; +extern GrB_Semiring GxB_ANY_PLUS_UINT8; +extern GrB_Semiring GxB_ANY_PLUS_UINT16; +extern GrB_Semiring GxB_ANY_PLUS_UINT32; +extern GrB_Semiring GxB_ANY_PLUS_UINT64; +extern GrB_Semiring GxB_ANY_RDIV_FC32; +extern GrB_Semiring GxB_ANY_RDIV_FC64; +extern GrB_Semiring GxB_ANY_RDIV_FP32; +extern GrB_Semiring GxB_ANY_RDIV_FP64; +extern GrB_Semiring GxB_ANY_RDIV_INT8; +extern GrB_Semiring GxB_ANY_RDIV_INT16; +extern GrB_Semiring GxB_ANY_RDIV_INT32; +extern GrB_Semiring GxB_ANY_RDIV_INT64; +extern GrB_Semiring GxB_ANY_RDIV_UINT8; +extern GrB_Semiring GxB_ANY_RDIV_UINT16; +extern GrB_Semiring GxB_ANY_RDIV_UINT32; +extern GrB_Semiring GxB_ANY_RDIV_UINT64; +extern GrB_Semiring GxB_ANY_RMINUS_FC32; +extern GrB_Semiring GxB_ANY_RMINUS_FC64; +extern GrB_Semiring GxB_ANY_RMINUS_FP32; +extern GrB_Semiring GxB_ANY_RMINUS_FP64; +extern GrB_Semiring GxB_ANY_RMINUS_INT8; +extern GrB_Semiring GxB_ANY_RMINUS_INT16; +extern GrB_Semiring GxB_ANY_RMINUS_INT32; +extern GrB_Semiring GxB_ANY_RMINUS_INT64; +extern GrB_Semiring GxB_ANY_RMINUS_UINT8; +extern GrB_Semiring GxB_ANY_RMINUS_UINT16; +extern GrB_Semiring GxB_ANY_RMINUS_UINT32; +extern GrB_Semiring GxB_ANY_RMINUS_UINT64; +extern GrB_Semiring GxB_ANY_SECONDI1_INT32; +extern GrB_Semiring GxB_ANY_SECONDI1_INT64; +extern GrB_Semiring GxB_ANY_SECONDI_INT32; +extern GrB_Semiring GxB_ANY_SECONDI_INT64; +extern GrB_Semiring GxB_ANY_SECONDJ1_INT32; +extern GrB_Semiring GxB_ANY_SECONDJ1_INT64; +extern GrB_Semiring GxB_ANY_SECONDJ_INT32; +extern GrB_Semiring GxB_ANY_SECONDJ_INT64; +extern GrB_Semiring GxB_ANY_SECOND_BOOL; +extern GrB_Semiring GxB_ANY_SECOND_FC32; +extern GrB_Semiring GxB_ANY_SECOND_FC64; +extern GrB_Semiring GxB_ANY_SECOND_FP32; +extern GrB_Semiring GxB_ANY_SECOND_FP64; +extern GrB_Semiring GxB_ANY_SECOND_INT8; +extern GrB_Semiring GxB_ANY_SECOND_INT16; +extern GrB_Semiring GxB_ANY_SECOND_INT32; +extern GrB_Semiring GxB_ANY_SECOND_INT64; +extern GrB_Semiring GxB_ANY_SECOND_UINT8; +extern GrB_Semiring GxB_ANY_SECOND_UINT16; +extern GrB_Semiring GxB_ANY_SECOND_UINT32; +extern GrB_Semiring GxB_ANY_SECOND_UINT64; +extern GrB_Semiring GxB_ANY_TIMES_FC32; +extern GrB_Semiring GxB_ANY_TIMES_FC64; +extern GrB_Semiring GxB_ANY_TIMES_FP32; +extern GrB_Semiring GxB_ANY_TIMES_FP64; +extern GrB_Semiring GxB_ANY_TIMES_INT8; +extern GrB_Semiring GxB_ANY_TIMES_INT16; +extern GrB_Semiring GxB_ANY_TIMES_INT32; +extern GrB_Semiring GxB_ANY_TIMES_INT64; +extern GrB_Semiring GxB_ANY_TIMES_UINT8; +extern GrB_Semiring GxB_ANY_TIMES_UINT16; +extern GrB_Semiring GxB_ANY_TIMES_UINT32; +extern GrB_Semiring GxB_ANY_TIMES_UINT64; +extern GrB_Semiring GxB_BAND_BAND_UINT8; +extern GrB_Semiring GxB_BAND_BAND_UINT16; +extern GrB_Semiring GxB_BAND_BAND_UINT32; +extern GrB_Semiring GxB_BAND_BAND_UINT64; +extern GrB_Semiring GxB_BAND_BOR_UINT8; +extern GrB_Semiring GxB_BAND_BOR_UINT16; +extern GrB_Semiring GxB_BAND_BOR_UINT32; +extern GrB_Semiring GxB_BAND_BOR_UINT64; +extern GrB_Semiring GxB_BAND_BXNOR_UINT8; +extern GrB_Semiring GxB_BAND_BXNOR_UINT16; +extern GrB_Semiring GxB_BAND_BXNOR_UINT32; +extern GrB_Semiring GxB_BAND_BXNOR_UINT64; +extern GrB_Semiring GxB_BAND_BXOR_UINT8; +extern GrB_Semiring GxB_BAND_BXOR_UINT16; +extern GrB_Semiring GxB_BAND_BXOR_UINT32; +extern GrB_Semiring GxB_BAND_BXOR_UINT64; +extern GrB_Semiring GxB_BOR_BAND_UINT8; +extern GrB_Semiring GxB_BOR_BAND_UINT16; +extern GrB_Semiring GxB_BOR_BAND_UINT32; +extern GrB_Semiring GxB_BOR_BAND_UINT64; +extern GrB_Semiring GxB_BOR_BOR_UINT8; +extern GrB_Semiring GxB_BOR_BOR_UINT16; +extern GrB_Semiring GxB_BOR_BOR_UINT32; +extern GrB_Semiring GxB_BOR_BOR_UINT64; +extern GrB_Semiring GxB_BOR_BXNOR_UINT8; +extern GrB_Semiring GxB_BOR_BXNOR_UINT16; +extern GrB_Semiring GxB_BOR_BXNOR_UINT32; +extern GrB_Semiring GxB_BOR_BXNOR_UINT64; +extern GrB_Semiring GxB_BOR_BXOR_UINT8; +extern GrB_Semiring GxB_BOR_BXOR_UINT16; +extern GrB_Semiring GxB_BOR_BXOR_UINT32; +extern GrB_Semiring GxB_BOR_BXOR_UINT64; +extern GrB_Semiring GxB_BXNOR_BAND_UINT8; +extern GrB_Semiring GxB_BXNOR_BAND_UINT16; +extern GrB_Semiring GxB_BXNOR_BAND_UINT32; +extern GrB_Semiring GxB_BXNOR_BAND_UINT64; +extern GrB_Semiring GxB_BXNOR_BOR_UINT8; +extern GrB_Semiring GxB_BXNOR_BOR_UINT16; +extern GrB_Semiring GxB_BXNOR_BOR_UINT32; +extern GrB_Semiring GxB_BXNOR_BOR_UINT64; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT8; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT16; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT32; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT64; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT8; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT16; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT32; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT64; +extern GrB_Semiring GxB_BXOR_BAND_UINT8; +extern GrB_Semiring GxB_BXOR_BAND_UINT16; +extern GrB_Semiring GxB_BXOR_BAND_UINT32; +extern GrB_Semiring GxB_BXOR_BAND_UINT64; +extern GrB_Semiring GxB_BXOR_BOR_UINT8; +extern GrB_Semiring GxB_BXOR_BOR_UINT16; +extern GrB_Semiring GxB_BXOR_BOR_UINT32; +extern GrB_Semiring GxB_BXOR_BOR_UINT64; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT8; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT16; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT32; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT64; +extern GrB_Semiring GxB_BXOR_BXOR_UINT8; +extern GrB_Semiring GxB_BXOR_BXOR_UINT16; +extern GrB_Semiring GxB_BXOR_BXOR_UINT32; +extern GrB_Semiring GxB_BXOR_BXOR_UINT64; +extern GrB_Semiring GxB_EQ_EQ_BOOL; +extern GrB_Semiring GxB_EQ_EQ_FP32; +extern GrB_Semiring GxB_EQ_EQ_FP64; +extern GrB_Semiring GxB_EQ_EQ_INT8; +extern GrB_Semiring GxB_EQ_EQ_INT16; +extern GrB_Semiring GxB_EQ_EQ_INT32; +extern GrB_Semiring GxB_EQ_EQ_INT64; +extern GrB_Semiring GxB_EQ_EQ_UINT8; +extern GrB_Semiring GxB_EQ_EQ_UINT16; +extern GrB_Semiring GxB_EQ_EQ_UINT32; +extern GrB_Semiring GxB_EQ_EQ_UINT64; +extern GrB_Semiring GxB_EQ_FIRST_BOOL; +extern GrB_Semiring GxB_EQ_GE_BOOL; +extern GrB_Semiring GxB_EQ_GE_FP32; +extern GrB_Semiring GxB_EQ_GE_FP64; +extern GrB_Semiring GxB_EQ_GE_INT8; +extern GrB_Semiring GxB_EQ_GE_INT16; +extern GrB_Semiring GxB_EQ_GE_INT32; +extern GrB_Semiring GxB_EQ_GE_INT64; +extern GrB_Semiring GxB_EQ_GE_UINT8; +extern GrB_Semiring GxB_EQ_GE_UINT16; +extern GrB_Semiring GxB_EQ_GE_UINT32; +extern GrB_Semiring GxB_EQ_GE_UINT64; +extern GrB_Semiring GxB_EQ_GT_BOOL; +extern GrB_Semiring GxB_EQ_GT_FP32; +extern GrB_Semiring GxB_EQ_GT_FP64; +extern GrB_Semiring GxB_EQ_GT_INT8; +extern GrB_Semiring GxB_EQ_GT_INT16; +extern GrB_Semiring GxB_EQ_GT_INT32; +extern GrB_Semiring GxB_EQ_GT_INT64; +extern GrB_Semiring GxB_EQ_GT_UINT8; +extern GrB_Semiring GxB_EQ_GT_UINT16; +extern GrB_Semiring GxB_EQ_GT_UINT32; +extern GrB_Semiring GxB_EQ_GT_UINT64; +extern GrB_Semiring GxB_EQ_LAND_BOOL; +extern GrB_Semiring GxB_EQ_LE_BOOL; +extern GrB_Semiring GxB_EQ_LE_FP32; +extern GrB_Semiring GxB_EQ_LE_FP64; +extern GrB_Semiring GxB_EQ_LE_INT8; +extern GrB_Semiring GxB_EQ_LE_INT16; +extern GrB_Semiring GxB_EQ_LE_INT32; +extern GrB_Semiring GxB_EQ_LE_INT64; +extern GrB_Semiring GxB_EQ_LE_UINT8; +extern GrB_Semiring GxB_EQ_LE_UINT16; +extern GrB_Semiring GxB_EQ_LE_UINT32; +extern GrB_Semiring GxB_EQ_LE_UINT64; +extern GrB_Semiring GxB_EQ_LOR_BOOL; +extern GrB_Semiring GxB_EQ_LT_BOOL; +extern GrB_Semiring GxB_EQ_LT_FP32; +extern GrB_Semiring GxB_EQ_LT_FP64; +extern GrB_Semiring GxB_EQ_LT_INT8; +extern GrB_Semiring GxB_EQ_LT_INT16; +extern GrB_Semiring GxB_EQ_LT_INT32; +extern GrB_Semiring GxB_EQ_LT_INT64; +extern GrB_Semiring GxB_EQ_LT_UINT8; +extern GrB_Semiring GxB_EQ_LT_UINT16; +extern GrB_Semiring GxB_EQ_LT_UINT32; +extern GrB_Semiring GxB_EQ_LT_UINT64; +extern GrB_Semiring GxB_EQ_LXOR_BOOL; +extern GrB_Semiring GxB_EQ_NE_FP32; +extern GrB_Semiring GxB_EQ_NE_FP64; +extern GrB_Semiring GxB_EQ_NE_INT8; +extern GrB_Semiring GxB_EQ_NE_INT16; +extern GrB_Semiring GxB_EQ_NE_INT32; +extern GrB_Semiring GxB_EQ_NE_INT64; +extern GrB_Semiring GxB_EQ_NE_UINT8; +extern GrB_Semiring GxB_EQ_NE_UINT16; +extern GrB_Semiring GxB_EQ_NE_UINT32; +extern GrB_Semiring GxB_EQ_NE_UINT64; +extern GrB_Semiring GxB_EQ_PAIR_BOOL; +extern GrB_Semiring GxB_EQ_SECOND_BOOL; +extern GrB_Semiring GxB_LAND_EQ_BOOL; +extern GrB_Semiring GxB_LAND_EQ_FP32; +extern GrB_Semiring GxB_LAND_EQ_FP64; +extern GrB_Semiring GxB_LAND_EQ_INT8; +extern GrB_Semiring GxB_LAND_EQ_INT16; +extern GrB_Semiring GxB_LAND_EQ_INT32; +extern GrB_Semiring GxB_LAND_EQ_INT64; +extern GrB_Semiring GxB_LAND_EQ_UINT8; +extern GrB_Semiring GxB_LAND_EQ_UINT16; +extern GrB_Semiring GxB_LAND_EQ_UINT32; +extern GrB_Semiring GxB_LAND_EQ_UINT64; +extern GrB_Semiring GxB_LAND_FIRST_BOOL; +extern GrB_Semiring GxB_LAND_GE_BOOL; +extern GrB_Semiring GxB_LAND_GE_FP32; +extern GrB_Semiring GxB_LAND_GE_FP64; +extern GrB_Semiring GxB_LAND_GE_INT8; +extern GrB_Semiring GxB_LAND_GE_INT16; +extern GrB_Semiring GxB_LAND_GE_INT32; +extern GrB_Semiring GxB_LAND_GE_INT64; +extern GrB_Semiring GxB_LAND_GE_UINT8; +extern GrB_Semiring GxB_LAND_GE_UINT16; +extern GrB_Semiring GxB_LAND_GE_UINT32; +extern GrB_Semiring GxB_LAND_GE_UINT64; +extern GrB_Semiring GxB_LAND_GT_BOOL; +extern GrB_Semiring GxB_LAND_GT_FP32; +extern GrB_Semiring GxB_LAND_GT_FP64; +extern GrB_Semiring GxB_LAND_GT_INT8; +extern GrB_Semiring GxB_LAND_GT_INT16; +extern GrB_Semiring GxB_LAND_GT_INT32; +extern GrB_Semiring GxB_LAND_GT_INT64; +extern GrB_Semiring GxB_LAND_GT_UINT8; +extern GrB_Semiring GxB_LAND_GT_UINT16; +extern GrB_Semiring GxB_LAND_GT_UINT32; +extern GrB_Semiring GxB_LAND_GT_UINT64; +extern GrB_Semiring GxB_LAND_LAND_BOOL; +extern GrB_Semiring GxB_LAND_LE_BOOL; +extern GrB_Semiring GxB_LAND_LE_FP32; +extern GrB_Semiring GxB_LAND_LE_FP64; +extern GrB_Semiring GxB_LAND_LE_INT8; +extern GrB_Semiring GxB_LAND_LE_INT16; +extern GrB_Semiring GxB_LAND_LE_INT32; +extern GrB_Semiring GxB_LAND_LE_INT64; +extern GrB_Semiring GxB_LAND_LE_UINT8; +extern GrB_Semiring GxB_LAND_LE_UINT16; +extern GrB_Semiring GxB_LAND_LE_UINT32; +extern GrB_Semiring GxB_LAND_LE_UINT64; +extern GrB_Semiring GxB_LAND_LT_BOOL; +extern GrB_Semiring GxB_LAND_LT_FP32; +extern GrB_Semiring GxB_LAND_LT_FP64; +extern GrB_Semiring GxB_LAND_LT_INT8; +extern GrB_Semiring GxB_LAND_LT_INT16; +extern GrB_Semiring GxB_LAND_LT_INT32; +extern GrB_Semiring GxB_LAND_LT_INT64; +extern GrB_Semiring GxB_LAND_LT_UINT8; +extern GrB_Semiring GxB_LAND_LT_UINT16; +extern GrB_Semiring GxB_LAND_LT_UINT32; +extern GrB_Semiring GxB_LAND_LT_UINT64; +extern GrB_Semiring GxB_LAND_LXOR_BOOL; +extern GrB_Semiring GxB_LAND_NE_FP32; +extern GrB_Semiring GxB_LAND_NE_FP64; +extern GrB_Semiring GxB_LAND_NE_INT8; +extern GrB_Semiring GxB_LAND_NE_INT16; +extern GrB_Semiring GxB_LAND_NE_INT32; +extern GrB_Semiring GxB_LAND_NE_INT64; +extern GrB_Semiring GxB_LAND_NE_UINT8; +extern GrB_Semiring GxB_LAND_NE_UINT16; +extern GrB_Semiring GxB_LAND_NE_UINT32; +extern GrB_Semiring GxB_LAND_NE_UINT64; +extern GrB_Semiring GxB_LAND_PAIR_BOOL; +extern GrB_Semiring GxB_LAND_SECOND_BOOL; +extern GrB_Semiring GxB_LOR_EQ_BOOL; +extern GrB_Semiring GxB_LOR_EQ_FP32; +extern GrB_Semiring GxB_LOR_EQ_FP64; +extern GrB_Semiring GxB_LOR_EQ_INT8; +extern GrB_Semiring GxB_LOR_EQ_INT16; +extern GrB_Semiring GxB_LOR_EQ_INT32; +extern GrB_Semiring GxB_LOR_EQ_INT64; +extern GrB_Semiring GxB_LOR_EQ_UINT8; +extern GrB_Semiring GxB_LOR_EQ_UINT16; +extern GrB_Semiring GxB_LOR_EQ_UINT32; +extern GrB_Semiring GxB_LOR_EQ_UINT64; +extern GrB_Semiring GxB_LOR_FIRST_BOOL; +extern GrB_Semiring GxB_LOR_GE_BOOL; +extern GrB_Semiring GxB_LOR_GE_FP32; +extern GrB_Semiring GxB_LOR_GE_FP64; +extern GrB_Semiring GxB_LOR_GE_INT8; +extern GrB_Semiring GxB_LOR_GE_INT16; +extern GrB_Semiring GxB_LOR_GE_INT32; +extern GrB_Semiring GxB_LOR_GE_INT64; +extern GrB_Semiring GxB_LOR_GE_UINT8; +extern GrB_Semiring GxB_LOR_GE_UINT16; +extern GrB_Semiring GxB_LOR_GE_UINT32; +extern GrB_Semiring GxB_LOR_GE_UINT64; +extern GrB_Semiring GxB_LOR_GT_BOOL; +extern GrB_Semiring GxB_LOR_GT_FP32; +extern GrB_Semiring GxB_LOR_GT_FP64; +extern GrB_Semiring GxB_LOR_GT_INT8; +extern GrB_Semiring GxB_LOR_GT_INT16; +extern GrB_Semiring GxB_LOR_GT_INT32; +extern GrB_Semiring GxB_LOR_GT_INT64; +extern GrB_Semiring GxB_LOR_GT_UINT8; +extern GrB_Semiring GxB_LOR_GT_UINT16; +extern GrB_Semiring GxB_LOR_GT_UINT32; +extern GrB_Semiring GxB_LOR_GT_UINT64; +extern GrB_Semiring GxB_LOR_LE_BOOL; +extern GrB_Semiring GxB_LOR_LE_FP32; +extern GrB_Semiring GxB_LOR_LE_FP64; +extern GrB_Semiring GxB_LOR_LE_INT8; +extern GrB_Semiring GxB_LOR_LE_INT16; +extern GrB_Semiring GxB_LOR_LE_INT32; +extern GrB_Semiring GxB_LOR_LE_INT64; +extern GrB_Semiring GxB_LOR_LE_UINT8; +extern GrB_Semiring GxB_LOR_LE_UINT16; +extern GrB_Semiring GxB_LOR_LE_UINT32; +extern GrB_Semiring GxB_LOR_LE_UINT64; +extern GrB_Semiring GxB_LOR_LOR_BOOL; +extern GrB_Semiring GxB_LOR_LT_BOOL; +extern GrB_Semiring GxB_LOR_LT_FP32; +extern GrB_Semiring GxB_LOR_LT_FP64; +extern GrB_Semiring GxB_LOR_LT_INT8; +extern GrB_Semiring GxB_LOR_LT_INT16; +extern GrB_Semiring GxB_LOR_LT_INT32; +extern GrB_Semiring GxB_LOR_LT_INT64; +extern GrB_Semiring GxB_LOR_LT_UINT8; +extern GrB_Semiring GxB_LOR_LT_UINT16; +extern GrB_Semiring GxB_LOR_LT_UINT32; +extern GrB_Semiring GxB_LOR_LT_UINT64; +extern GrB_Semiring GxB_LOR_LXOR_BOOL; +extern GrB_Semiring GxB_LOR_NE_FP32; +extern GrB_Semiring GxB_LOR_NE_FP64; +extern GrB_Semiring GxB_LOR_NE_INT8; +extern GrB_Semiring GxB_LOR_NE_INT16; +extern GrB_Semiring GxB_LOR_NE_INT32; +extern GrB_Semiring GxB_LOR_NE_INT64; +extern GrB_Semiring GxB_LOR_NE_UINT8; +extern GrB_Semiring GxB_LOR_NE_UINT16; +extern GrB_Semiring GxB_LOR_NE_UINT32; +extern GrB_Semiring GxB_LOR_NE_UINT64; +extern GrB_Semiring GxB_LOR_PAIR_BOOL; +extern GrB_Semiring GxB_LOR_SECOND_BOOL; +extern GrB_Semiring GxB_LXOR_EQ_BOOL; +extern GrB_Semiring GxB_LXOR_EQ_FP32; +extern GrB_Semiring GxB_LXOR_EQ_FP64; +extern GrB_Semiring GxB_LXOR_EQ_INT8; +extern GrB_Semiring GxB_LXOR_EQ_INT16; +extern GrB_Semiring GxB_LXOR_EQ_INT32; +extern GrB_Semiring GxB_LXOR_EQ_INT64; +extern GrB_Semiring GxB_LXOR_EQ_UINT8; +extern GrB_Semiring GxB_LXOR_EQ_UINT16; +extern GrB_Semiring GxB_LXOR_EQ_UINT32; +extern GrB_Semiring GxB_LXOR_EQ_UINT64; +extern GrB_Semiring GxB_LXOR_FIRST_BOOL; +extern GrB_Semiring GxB_LXOR_GE_BOOL; +extern GrB_Semiring GxB_LXOR_GE_FP32; +extern GrB_Semiring GxB_LXOR_GE_FP64; +extern GrB_Semiring GxB_LXOR_GE_INT8; +extern GrB_Semiring GxB_LXOR_GE_INT16; +extern GrB_Semiring GxB_LXOR_GE_INT32; +extern GrB_Semiring GxB_LXOR_GE_INT64; +extern GrB_Semiring GxB_LXOR_GE_UINT8; +extern GrB_Semiring GxB_LXOR_GE_UINT16; +extern GrB_Semiring GxB_LXOR_GE_UINT32; +extern GrB_Semiring GxB_LXOR_GE_UINT64; +extern GrB_Semiring GxB_LXOR_GT_BOOL; +extern GrB_Semiring GxB_LXOR_GT_FP32; +extern GrB_Semiring GxB_LXOR_GT_FP64; +extern GrB_Semiring GxB_LXOR_GT_INT8; +extern GrB_Semiring GxB_LXOR_GT_INT16; +extern GrB_Semiring GxB_LXOR_GT_INT32; +extern GrB_Semiring GxB_LXOR_GT_INT64; +extern GrB_Semiring GxB_LXOR_GT_UINT8; +extern GrB_Semiring GxB_LXOR_GT_UINT16; +extern GrB_Semiring GxB_LXOR_GT_UINT32; +extern GrB_Semiring GxB_LXOR_GT_UINT64; +extern GrB_Semiring GxB_LXOR_LE_BOOL; +extern GrB_Semiring GxB_LXOR_LE_FP32; +extern GrB_Semiring GxB_LXOR_LE_FP64; +extern GrB_Semiring GxB_LXOR_LE_INT8; +extern GrB_Semiring GxB_LXOR_LE_INT16; +extern GrB_Semiring GxB_LXOR_LE_INT32; +extern GrB_Semiring GxB_LXOR_LE_INT64; +extern GrB_Semiring GxB_LXOR_LE_UINT8; +extern GrB_Semiring GxB_LXOR_LE_UINT16; +extern GrB_Semiring GxB_LXOR_LE_UINT32; +extern GrB_Semiring GxB_LXOR_LE_UINT64; +extern GrB_Semiring GxB_LXOR_LOR_BOOL; +extern GrB_Semiring GxB_LXOR_LT_BOOL; +extern GrB_Semiring GxB_LXOR_LT_FP32; +extern GrB_Semiring GxB_LXOR_LT_FP64; +extern GrB_Semiring GxB_LXOR_LT_INT8; +extern GrB_Semiring GxB_LXOR_LT_INT16; +extern GrB_Semiring GxB_LXOR_LT_INT32; +extern GrB_Semiring GxB_LXOR_LT_INT64; +extern GrB_Semiring GxB_LXOR_LT_UINT8; +extern GrB_Semiring GxB_LXOR_LT_UINT16; +extern GrB_Semiring GxB_LXOR_LT_UINT32; +extern GrB_Semiring GxB_LXOR_LT_UINT64; +extern GrB_Semiring GxB_LXOR_LXOR_BOOL; +extern GrB_Semiring GxB_LXOR_NE_FP32; +extern GrB_Semiring GxB_LXOR_NE_FP64; +extern GrB_Semiring GxB_LXOR_NE_INT8; +extern GrB_Semiring GxB_LXOR_NE_INT16; +extern GrB_Semiring GxB_LXOR_NE_INT32; +extern GrB_Semiring GxB_LXOR_NE_INT64; +extern GrB_Semiring GxB_LXOR_NE_UINT8; +extern GrB_Semiring GxB_LXOR_NE_UINT16; +extern GrB_Semiring GxB_LXOR_NE_UINT32; +extern GrB_Semiring GxB_LXOR_NE_UINT64; +extern GrB_Semiring GxB_LXOR_PAIR_BOOL; +extern GrB_Semiring GxB_LXOR_SECOND_BOOL; +extern GrB_Semiring GxB_MAX_DIV_FP32; +extern GrB_Semiring GxB_MAX_DIV_FP64; +extern GrB_Semiring GxB_MAX_DIV_INT8; +extern GrB_Semiring GxB_MAX_DIV_INT16; +extern GrB_Semiring GxB_MAX_DIV_INT32; +extern GrB_Semiring GxB_MAX_DIV_INT64; +extern GrB_Semiring GxB_MAX_DIV_UINT8; +extern GrB_Semiring GxB_MAX_DIV_UINT16; +extern GrB_Semiring GxB_MAX_DIV_UINT32; +extern GrB_Semiring GxB_MAX_DIV_UINT64; +extern GrB_Semiring GxB_MAX_FIRSTI1_INT32; +extern GrB_Semiring GxB_MAX_FIRSTI1_INT64; +extern GrB_Semiring GxB_MAX_FIRSTI_INT32; +extern GrB_Semiring GxB_MAX_FIRSTI_INT64; +extern GrB_Semiring GxB_MAX_FIRSTJ1_INT32; +extern GrB_Semiring GxB_MAX_FIRSTJ1_INT64; +extern GrB_Semiring GxB_MAX_FIRSTJ_INT32; +extern GrB_Semiring GxB_MAX_FIRSTJ_INT64; +extern GrB_Semiring GxB_MAX_ISEQ_FP32; +extern GrB_Semiring GxB_MAX_ISEQ_FP64; +extern GrB_Semiring GxB_MAX_ISEQ_INT8; +extern GrB_Semiring GxB_MAX_ISEQ_INT16; +extern GrB_Semiring GxB_MAX_ISEQ_INT32; +extern GrB_Semiring GxB_MAX_ISEQ_INT64; +extern GrB_Semiring GxB_MAX_ISEQ_UINT8; +extern GrB_Semiring GxB_MAX_ISEQ_UINT16; +extern GrB_Semiring GxB_MAX_ISEQ_UINT32; +extern GrB_Semiring GxB_MAX_ISEQ_UINT64; +extern GrB_Semiring GxB_MAX_ISGE_FP32; +extern GrB_Semiring GxB_MAX_ISGE_FP64; +extern GrB_Semiring GxB_MAX_ISGE_INT8; +extern GrB_Semiring GxB_MAX_ISGE_INT16; +extern GrB_Semiring GxB_MAX_ISGE_INT32; +extern GrB_Semiring GxB_MAX_ISGE_INT64; +extern GrB_Semiring GxB_MAX_ISGE_UINT8; +extern GrB_Semiring GxB_MAX_ISGE_UINT16; +extern GrB_Semiring GxB_MAX_ISGE_UINT32; +extern GrB_Semiring GxB_MAX_ISGE_UINT64; +extern GrB_Semiring GxB_MAX_ISGT_FP32; +extern GrB_Semiring GxB_MAX_ISGT_FP64; +extern GrB_Semiring GxB_MAX_ISGT_INT8; +extern GrB_Semiring GxB_MAX_ISGT_INT16; +extern GrB_Semiring GxB_MAX_ISGT_INT32; +extern GrB_Semiring GxB_MAX_ISGT_INT64; +extern GrB_Semiring GxB_MAX_ISGT_UINT8; +extern GrB_Semiring GxB_MAX_ISGT_UINT16; +extern GrB_Semiring GxB_MAX_ISGT_UINT32; +extern GrB_Semiring GxB_MAX_ISGT_UINT64; +extern GrB_Semiring GxB_MAX_ISLE_FP32; +extern GrB_Semiring GxB_MAX_ISLE_FP64; +extern GrB_Semiring GxB_MAX_ISLE_INT8; +extern GrB_Semiring GxB_MAX_ISLE_INT16; +extern GrB_Semiring GxB_MAX_ISLE_INT32; +extern GrB_Semiring GxB_MAX_ISLE_INT64; +extern GrB_Semiring GxB_MAX_ISLE_UINT8; +extern GrB_Semiring GxB_MAX_ISLE_UINT16; +extern GrB_Semiring GxB_MAX_ISLE_UINT32; +extern GrB_Semiring GxB_MAX_ISLE_UINT64; +extern GrB_Semiring GxB_MAX_ISLT_FP32; +extern GrB_Semiring GxB_MAX_ISLT_FP64; +extern GrB_Semiring GxB_MAX_ISLT_INT8; +extern GrB_Semiring GxB_MAX_ISLT_INT16; +extern GrB_Semiring GxB_MAX_ISLT_INT32; +extern GrB_Semiring GxB_MAX_ISLT_INT64; +extern GrB_Semiring GxB_MAX_ISLT_UINT8; +extern GrB_Semiring GxB_MAX_ISLT_UINT16; +extern GrB_Semiring GxB_MAX_ISLT_UINT32; +extern GrB_Semiring GxB_MAX_ISLT_UINT64; +extern GrB_Semiring GxB_MAX_ISNE_FP32; +extern GrB_Semiring GxB_MAX_ISNE_FP64; +extern GrB_Semiring GxB_MAX_ISNE_INT8; +extern GrB_Semiring GxB_MAX_ISNE_INT16; +extern GrB_Semiring GxB_MAX_ISNE_INT32; +extern GrB_Semiring GxB_MAX_ISNE_INT64; +extern GrB_Semiring GxB_MAX_ISNE_UINT8; +extern GrB_Semiring GxB_MAX_ISNE_UINT16; +extern GrB_Semiring GxB_MAX_ISNE_UINT32; +extern GrB_Semiring GxB_MAX_ISNE_UINT64; +extern GrB_Semiring GxB_MAX_LAND_FP32; +extern GrB_Semiring GxB_MAX_LAND_FP64; +extern GrB_Semiring GxB_MAX_LAND_INT8; +extern GrB_Semiring GxB_MAX_LAND_INT16; +extern GrB_Semiring GxB_MAX_LAND_INT32; +extern GrB_Semiring GxB_MAX_LAND_INT64; +extern GrB_Semiring GxB_MAX_LAND_UINT8; +extern GrB_Semiring GxB_MAX_LAND_UINT16; +extern GrB_Semiring GxB_MAX_LAND_UINT32; +extern GrB_Semiring GxB_MAX_LAND_UINT64; +extern GrB_Semiring GxB_MAX_LOR_FP32; +extern GrB_Semiring GxB_MAX_LOR_FP64; +extern GrB_Semiring GxB_MAX_LOR_INT8; +extern GrB_Semiring GxB_MAX_LOR_INT16; +extern GrB_Semiring GxB_MAX_LOR_INT32; +extern GrB_Semiring GxB_MAX_LOR_INT64; +extern GrB_Semiring GxB_MAX_LOR_UINT8; +extern GrB_Semiring GxB_MAX_LOR_UINT16; +extern GrB_Semiring GxB_MAX_LOR_UINT32; +extern GrB_Semiring GxB_MAX_LOR_UINT64; +extern GrB_Semiring GxB_MAX_LXOR_FP32; +extern GrB_Semiring GxB_MAX_LXOR_FP64; +extern GrB_Semiring GxB_MAX_LXOR_INT8; +extern GrB_Semiring GxB_MAX_LXOR_INT16; +extern GrB_Semiring GxB_MAX_LXOR_INT32; +extern GrB_Semiring GxB_MAX_LXOR_INT64; +extern GrB_Semiring GxB_MAX_LXOR_UINT8; +extern GrB_Semiring GxB_MAX_LXOR_UINT16; +extern GrB_Semiring GxB_MAX_LXOR_UINT32; +extern GrB_Semiring GxB_MAX_LXOR_UINT64; +extern GrB_Semiring GxB_MAX_MAX_FP32; +extern GrB_Semiring GxB_MAX_MAX_FP64; +extern GrB_Semiring GxB_MAX_MAX_INT8; +extern GrB_Semiring GxB_MAX_MAX_INT16; +extern GrB_Semiring GxB_MAX_MAX_INT32; +extern GrB_Semiring GxB_MAX_MAX_INT64; +extern GrB_Semiring GxB_MAX_MAX_UINT8; +extern GrB_Semiring GxB_MAX_MAX_UINT16; +extern GrB_Semiring GxB_MAX_MAX_UINT32; +extern GrB_Semiring GxB_MAX_MAX_UINT64; +extern GrB_Semiring GxB_MAX_MINUS_FP32; +extern GrB_Semiring GxB_MAX_MINUS_FP64; +extern GrB_Semiring GxB_MAX_MINUS_INT8; +extern GrB_Semiring GxB_MAX_MINUS_INT16; +extern GrB_Semiring GxB_MAX_MINUS_INT32; +extern GrB_Semiring GxB_MAX_MINUS_INT64; +extern GrB_Semiring GxB_MAX_MINUS_UINT8; +extern GrB_Semiring GxB_MAX_MINUS_UINT16; +extern GrB_Semiring GxB_MAX_MINUS_UINT32; +extern GrB_Semiring GxB_MAX_MINUS_UINT64; +extern GrB_Semiring GxB_MAX_PAIR_FP32; +extern GrB_Semiring GxB_MAX_PAIR_FP64; +extern GrB_Semiring GxB_MAX_PAIR_INT8; +extern GrB_Semiring GxB_MAX_PAIR_INT16; +extern GrB_Semiring GxB_MAX_PAIR_INT32; +extern GrB_Semiring GxB_MAX_PAIR_INT64; +extern GrB_Semiring GxB_MAX_PAIR_UINT8; +extern GrB_Semiring GxB_MAX_PAIR_UINT16; +extern GrB_Semiring GxB_MAX_PAIR_UINT32; +extern GrB_Semiring GxB_MAX_PAIR_UINT64; +extern GrB_Semiring GxB_MAX_RDIV_FP32; +extern GrB_Semiring GxB_MAX_RDIV_FP64; +extern GrB_Semiring GxB_MAX_RDIV_INT8; +extern GrB_Semiring GxB_MAX_RDIV_INT16; +extern GrB_Semiring GxB_MAX_RDIV_INT32; +extern GrB_Semiring GxB_MAX_RDIV_INT64; +extern GrB_Semiring GxB_MAX_RDIV_UINT8; +extern GrB_Semiring GxB_MAX_RDIV_UINT16; +extern GrB_Semiring GxB_MAX_RDIV_UINT32; +extern GrB_Semiring GxB_MAX_RDIV_UINT64; +extern GrB_Semiring GxB_MAX_RMINUS_FP32; +extern GrB_Semiring GxB_MAX_RMINUS_FP64; +extern GrB_Semiring GxB_MAX_RMINUS_INT8; +extern GrB_Semiring GxB_MAX_RMINUS_INT16; +extern GrB_Semiring GxB_MAX_RMINUS_INT32; +extern GrB_Semiring GxB_MAX_RMINUS_INT64; +extern GrB_Semiring GxB_MAX_RMINUS_UINT8; +extern GrB_Semiring GxB_MAX_RMINUS_UINT16; +extern GrB_Semiring GxB_MAX_RMINUS_UINT32; +extern GrB_Semiring GxB_MAX_RMINUS_UINT64; +extern GrB_Semiring GxB_MAX_SECONDI1_INT32; +extern GrB_Semiring GxB_MAX_SECONDI1_INT64; +extern GrB_Semiring GxB_MAX_SECONDI_INT32; +extern GrB_Semiring GxB_MAX_SECONDI_INT64; +extern GrB_Semiring GxB_MAX_SECONDJ1_INT32; +extern GrB_Semiring GxB_MAX_SECONDJ1_INT64; +extern GrB_Semiring GxB_MAX_SECONDJ_INT32; +extern GrB_Semiring GxB_MAX_SECONDJ_INT64; +extern GrB_Semiring GxB_MIN_DIV_FP32; +extern GrB_Semiring GxB_MIN_DIV_FP64; +extern GrB_Semiring GxB_MIN_DIV_INT8; +extern GrB_Semiring GxB_MIN_DIV_INT16; +extern GrB_Semiring GxB_MIN_DIV_INT32; +extern GrB_Semiring GxB_MIN_DIV_INT64; +extern GrB_Semiring GxB_MIN_DIV_UINT8; +extern GrB_Semiring GxB_MIN_DIV_UINT16; +extern GrB_Semiring GxB_MIN_DIV_UINT32; +extern GrB_Semiring GxB_MIN_DIV_UINT64; +extern GrB_Semiring GxB_MIN_FIRSTI1_INT32; +extern GrB_Semiring GxB_MIN_FIRSTI1_INT64; +extern GrB_Semiring GxB_MIN_FIRSTI_INT32; +extern GrB_Semiring GxB_MIN_FIRSTI_INT64; +extern GrB_Semiring GxB_MIN_FIRSTJ1_INT32; +extern GrB_Semiring GxB_MIN_FIRSTJ1_INT64; +extern GrB_Semiring GxB_MIN_FIRSTJ_INT32; +extern GrB_Semiring GxB_MIN_FIRSTJ_INT64; +extern GrB_Semiring GxB_MIN_ISEQ_FP32; +extern GrB_Semiring GxB_MIN_ISEQ_FP64; +extern GrB_Semiring GxB_MIN_ISEQ_INT8; +extern GrB_Semiring GxB_MIN_ISEQ_INT16; +extern GrB_Semiring GxB_MIN_ISEQ_INT32; +extern GrB_Semiring GxB_MIN_ISEQ_INT64; +extern GrB_Semiring GxB_MIN_ISEQ_UINT8; +extern GrB_Semiring GxB_MIN_ISEQ_UINT16; +extern GrB_Semiring GxB_MIN_ISEQ_UINT32; +extern GrB_Semiring GxB_MIN_ISEQ_UINT64; +extern GrB_Semiring GxB_MIN_ISGE_FP32; +extern GrB_Semiring GxB_MIN_ISGE_FP64; +extern GrB_Semiring GxB_MIN_ISGE_INT8; +extern GrB_Semiring GxB_MIN_ISGE_INT16; +extern GrB_Semiring GxB_MIN_ISGE_INT32; +extern GrB_Semiring GxB_MIN_ISGE_INT64; +extern GrB_Semiring GxB_MIN_ISGE_UINT8; +extern GrB_Semiring GxB_MIN_ISGE_UINT16; +extern GrB_Semiring GxB_MIN_ISGE_UINT32; +extern GrB_Semiring GxB_MIN_ISGE_UINT64; +extern GrB_Semiring GxB_MIN_ISGT_FP32; +extern GrB_Semiring GxB_MIN_ISGT_FP64; +extern GrB_Semiring GxB_MIN_ISGT_INT8; +extern GrB_Semiring GxB_MIN_ISGT_INT16; +extern GrB_Semiring GxB_MIN_ISGT_INT32; +extern GrB_Semiring GxB_MIN_ISGT_INT64; +extern GrB_Semiring GxB_MIN_ISGT_UINT8; +extern GrB_Semiring GxB_MIN_ISGT_UINT16; +extern GrB_Semiring GxB_MIN_ISGT_UINT32; +extern GrB_Semiring GxB_MIN_ISGT_UINT64; +extern GrB_Semiring GxB_MIN_ISLE_FP32; +extern GrB_Semiring GxB_MIN_ISLE_FP64; +extern GrB_Semiring GxB_MIN_ISLE_INT8; +extern GrB_Semiring GxB_MIN_ISLE_INT16; +extern GrB_Semiring GxB_MIN_ISLE_INT32; +extern GrB_Semiring GxB_MIN_ISLE_INT64; +extern GrB_Semiring GxB_MIN_ISLE_UINT8; +extern GrB_Semiring GxB_MIN_ISLE_UINT16; +extern GrB_Semiring GxB_MIN_ISLE_UINT32; +extern GrB_Semiring GxB_MIN_ISLE_UINT64; +extern GrB_Semiring GxB_MIN_ISLT_FP32; +extern GrB_Semiring GxB_MIN_ISLT_FP64; +extern GrB_Semiring GxB_MIN_ISLT_INT8; +extern GrB_Semiring GxB_MIN_ISLT_INT16; +extern GrB_Semiring GxB_MIN_ISLT_INT32; +extern GrB_Semiring GxB_MIN_ISLT_INT64; +extern GrB_Semiring GxB_MIN_ISLT_UINT8; +extern GrB_Semiring GxB_MIN_ISLT_UINT16; +extern GrB_Semiring GxB_MIN_ISLT_UINT32; +extern GrB_Semiring GxB_MIN_ISLT_UINT64; +extern GrB_Semiring GxB_MIN_ISNE_FP32; +extern GrB_Semiring GxB_MIN_ISNE_FP64; +extern GrB_Semiring GxB_MIN_ISNE_INT8; +extern GrB_Semiring GxB_MIN_ISNE_INT16; +extern GrB_Semiring GxB_MIN_ISNE_INT32; +extern GrB_Semiring GxB_MIN_ISNE_INT64; +extern GrB_Semiring GxB_MIN_ISNE_UINT8; +extern GrB_Semiring GxB_MIN_ISNE_UINT16; +extern GrB_Semiring GxB_MIN_ISNE_UINT32; +extern GrB_Semiring GxB_MIN_ISNE_UINT64; +extern GrB_Semiring GxB_MIN_LAND_FP32; +extern GrB_Semiring GxB_MIN_LAND_FP64; +extern GrB_Semiring GxB_MIN_LAND_INT8; +extern GrB_Semiring GxB_MIN_LAND_INT16; +extern GrB_Semiring GxB_MIN_LAND_INT32; +extern GrB_Semiring GxB_MIN_LAND_INT64; +extern GrB_Semiring GxB_MIN_LAND_UINT8; +extern GrB_Semiring GxB_MIN_LAND_UINT16; +extern GrB_Semiring GxB_MIN_LAND_UINT32; +extern GrB_Semiring GxB_MIN_LAND_UINT64; +extern GrB_Semiring GxB_MIN_LOR_FP32; +extern GrB_Semiring GxB_MIN_LOR_FP64; +extern GrB_Semiring GxB_MIN_LOR_INT8; +extern GrB_Semiring GxB_MIN_LOR_INT16; +extern GrB_Semiring GxB_MIN_LOR_INT32; +extern GrB_Semiring GxB_MIN_LOR_INT64; +extern GrB_Semiring GxB_MIN_LOR_UINT8; +extern GrB_Semiring GxB_MIN_LOR_UINT16; +extern GrB_Semiring GxB_MIN_LOR_UINT32; +extern GrB_Semiring GxB_MIN_LOR_UINT64; +extern GrB_Semiring GxB_MIN_LXOR_FP32; +extern GrB_Semiring GxB_MIN_LXOR_FP64; +extern GrB_Semiring GxB_MIN_LXOR_INT8; +extern GrB_Semiring GxB_MIN_LXOR_INT16; +extern GrB_Semiring GxB_MIN_LXOR_INT32; +extern GrB_Semiring GxB_MIN_LXOR_INT64; +extern GrB_Semiring GxB_MIN_LXOR_UINT8; +extern GrB_Semiring GxB_MIN_LXOR_UINT16; +extern GrB_Semiring GxB_MIN_LXOR_UINT32; +extern GrB_Semiring GxB_MIN_LXOR_UINT64; +extern GrB_Semiring GxB_MIN_MINUS_FP32; +extern GrB_Semiring GxB_MIN_MINUS_FP64; +extern GrB_Semiring GxB_MIN_MINUS_INT8; +extern GrB_Semiring GxB_MIN_MINUS_INT16; +extern GrB_Semiring GxB_MIN_MINUS_INT32; +extern GrB_Semiring GxB_MIN_MINUS_INT64; +extern GrB_Semiring GxB_MIN_MINUS_UINT8; +extern GrB_Semiring GxB_MIN_MINUS_UINT16; +extern GrB_Semiring GxB_MIN_MINUS_UINT32; +extern GrB_Semiring GxB_MIN_MINUS_UINT64; +extern GrB_Semiring GxB_MIN_MIN_FP32; +extern GrB_Semiring GxB_MIN_MIN_FP64; +extern GrB_Semiring GxB_MIN_MIN_INT8; +extern GrB_Semiring GxB_MIN_MIN_INT16; +extern GrB_Semiring GxB_MIN_MIN_INT32; +extern GrB_Semiring GxB_MIN_MIN_INT64; +extern GrB_Semiring GxB_MIN_MIN_UINT8; +extern GrB_Semiring GxB_MIN_MIN_UINT16; +extern GrB_Semiring GxB_MIN_MIN_UINT32; +extern GrB_Semiring GxB_MIN_MIN_UINT64; +extern GrB_Semiring GxB_MIN_PAIR_FP32; +extern GrB_Semiring GxB_MIN_PAIR_FP64; +extern GrB_Semiring GxB_MIN_PAIR_INT8; +extern GrB_Semiring GxB_MIN_PAIR_INT16; +extern GrB_Semiring GxB_MIN_PAIR_INT32; +extern GrB_Semiring GxB_MIN_PAIR_INT64; +extern GrB_Semiring GxB_MIN_PAIR_UINT8; +extern GrB_Semiring GxB_MIN_PAIR_UINT16; +extern GrB_Semiring GxB_MIN_PAIR_UINT32; +extern GrB_Semiring GxB_MIN_PAIR_UINT64; +extern GrB_Semiring GxB_MIN_RDIV_FP32; +extern GrB_Semiring GxB_MIN_RDIV_FP64; +extern GrB_Semiring GxB_MIN_RDIV_INT8; +extern GrB_Semiring GxB_MIN_RDIV_INT16; +extern GrB_Semiring GxB_MIN_RDIV_INT32; +extern GrB_Semiring GxB_MIN_RDIV_INT64; +extern GrB_Semiring GxB_MIN_RDIV_UINT8; +extern GrB_Semiring GxB_MIN_RDIV_UINT16; +extern GrB_Semiring GxB_MIN_RDIV_UINT32; +extern GrB_Semiring GxB_MIN_RDIV_UINT64; +extern GrB_Semiring GxB_MIN_RMINUS_FP32; +extern GrB_Semiring GxB_MIN_RMINUS_FP64; +extern GrB_Semiring GxB_MIN_RMINUS_INT8; +extern GrB_Semiring GxB_MIN_RMINUS_INT16; +extern GrB_Semiring GxB_MIN_RMINUS_INT32; +extern GrB_Semiring GxB_MIN_RMINUS_INT64; +extern GrB_Semiring GxB_MIN_RMINUS_UINT8; +extern GrB_Semiring GxB_MIN_RMINUS_UINT16; +extern GrB_Semiring GxB_MIN_RMINUS_UINT32; +extern GrB_Semiring GxB_MIN_RMINUS_UINT64; +extern GrB_Semiring GxB_MIN_SECONDI1_INT32; +extern GrB_Semiring GxB_MIN_SECONDI1_INT64; +extern GrB_Semiring GxB_MIN_SECONDI_INT32; +extern GrB_Semiring GxB_MIN_SECONDI_INT64; +extern GrB_Semiring GxB_MIN_SECONDJ1_INT32; +extern GrB_Semiring GxB_MIN_SECONDJ1_INT64; +extern GrB_Semiring GxB_MIN_SECONDJ_INT32; +extern GrB_Semiring GxB_MIN_SECONDJ_INT64; +extern GrB_Semiring GxB_PLUS_DIV_FC32; +extern GrB_Semiring GxB_PLUS_DIV_FC64; +extern GrB_Semiring GxB_PLUS_DIV_FP32; +extern GrB_Semiring GxB_PLUS_DIV_FP64; +extern GrB_Semiring GxB_PLUS_DIV_INT8; +extern GrB_Semiring GxB_PLUS_DIV_INT16; +extern GrB_Semiring GxB_PLUS_DIV_INT32; +extern GrB_Semiring GxB_PLUS_DIV_INT64; +extern GrB_Semiring GxB_PLUS_DIV_UINT8; +extern GrB_Semiring GxB_PLUS_DIV_UINT16; +extern GrB_Semiring GxB_PLUS_DIV_UINT32; +extern GrB_Semiring GxB_PLUS_DIV_UINT64; +extern GrB_Semiring GxB_PLUS_FIRSTI1_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTI1_INT64; +extern GrB_Semiring GxB_PLUS_FIRSTI_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTI_INT64; +extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT64; +extern GrB_Semiring GxB_PLUS_FIRSTJ_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTJ_INT64; +extern GrB_Semiring GxB_PLUS_FIRST_FC32; +extern GrB_Semiring GxB_PLUS_FIRST_FC64; +extern GrB_Semiring GxB_PLUS_FIRST_FP32; +extern GrB_Semiring GxB_PLUS_FIRST_FP64; +extern GrB_Semiring GxB_PLUS_FIRST_INT8; +extern GrB_Semiring GxB_PLUS_FIRST_INT16; +extern GrB_Semiring GxB_PLUS_FIRST_INT32; +extern GrB_Semiring GxB_PLUS_FIRST_INT64; +extern GrB_Semiring GxB_PLUS_FIRST_UINT8; +extern GrB_Semiring GxB_PLUS_FIRST_UINT16; +extern GrB_Semiring GxB_PLUS_FIRST_UINT32; +extern GrB_Semiring GxB_PLUS_FIRST_UINT64; +extern GrB_Semiring GxB_PLUS_ISEQ_FP32; +extern GrB_Semiring GxB_PLUS_ISEQ_FP64; +extern GrB_Semiring GxB_PLUS_ISEQ_INT8; +extern GrB_Semiring GxB_PLUS_ISEQ_INT16; +extern GrB_Semiring GxB_PLUS_ISEQ_INT32; +extern GrB_Semiring GxB_PLUS_ISEQ_INT64; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT8; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT16; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT32; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT64; +extern GrB_Semiring GxB_PLUS_ISGE_FP32; +extern GrB_Semiring GxB_PLUS_ISGE_FP64; +extern GrB_Semiring GxB_PLUS_ISGE_INT8; +extern GrB_Semiring GxB_PLUS_ISGE_INT16; +extern GrB_Semiring GxB_PLUS_ISGE_INT32; +extern GrB_Semiring GxB_PLUS_ISGE_INT64; +extern GrB_Semiring GxB_PLUS_ISGE_UINT8; +extern GrB_Semiring GxB_PLUS_ISGE_UINT16; +extern GrB_Semiring GxB_PLUS_ISGE_UINT32; +extern GrB_Semiring GxB_PLUS_ISGE_UINT64; +extern GrB_Semiring GxB_PLUS_ISGT_FP32; +extern GrB_Semiring GxB_PLUS_ISGT_FP64; +extern GrB_Semiring GxB_PLUS_ISGT_INT8; +extern GrB_Semiring GxB_PLUS_ISGT_INT16; +extern GrB_Semiring GxB_PLUS_ISGT_INT32; +extern GrB_Semiring GxB_PLUS_ISGT_INT64; +extern GrB_Semiring GxB_PLUS_ISGT_UINT8; +extern GrB_Semiring GxB_PLUS_ISGT_UINT16; +extern GrB_Semiring GxB_PLUS_ISGT_UINT32; +extern GrB_Semiring GxB_PLUS_ISGT_UINT64; +extern GrB_Semiring GxB_PLUS_ISLE_FP32; +extern GrB_Semiring GxB_PLUS_ISLE_FP64; +extern GrB_Semiring GxB_PLUS_ISLE_INT8; +extern GrB_Semiring GxB_PLUS_ISLE_INT16; +extern GrB_Semiring GxB_PLUS_ISLE_INT32; +extern GrB_Semiring GxB_PLUS_ISLE_INT64; +extern GrB_Semiring GxB_PLUS_ISLE_UINT8; +extern GrB_Semiring GxB_PLUS_ISLE_UINT16; +extern GrB_Semiring GxB_PLUS_ISLE_UINT32; +extern GrB_Semiring GxB_PLUS_ISLE_UINT64; +extern GrB_Semiring GxB_PLUS_ISLT_FP32; +extern GrB_Semiring GxB_PLUS_ISLT_FP64; +extern GrB_Semiring GxB_PLUS_ISLT_INT8; +extern GrB_Semiring GxB_PLUS_ISLT_INT16; +extern GrB_Semiring GxB_PLUS_ISLT_INT32; +extern GrB_Semiring GxB_PLUS_ISLT_INT64; +extern GrB_Semiring GxB_PLUS_ISLT_UINT8; +extern GrB_Semiring GxB_PLUS_ISLT_UINT16; +extern GrB_Semiring GxB_PLUS_ISLT_UINT32; +extern GrB_Semiring GxB_PLUS_ISLT_UINT64; +extern GrB_Semiring GxB_PLUS_ISNE_FP32; +extern GrB_Semiring GxB_PLUS_ISNE_FP64; +extern GrB_Semiring GxB_PLUS_ISNE_INT8; +extern GrB_Semiring GxB_PLUS_ISNE_INT16; +extern GrB_Semiring GxB_PLUS_ISNE_INT32; +extern GrB_Semiring GxB_PLUS_ISNE_INT64; +extern GrB_Semiring GxB_PLUS_ISNE_UINT8; +extern GrB_Semiring GxB_PLUS_ISNE_UINT16; +extern GrB_Semiring GxB_PLUS_ISNE_UINT32; +extern GrB_Semiring GxB_PLUS_ISNE_UINT64; +extern GrB_Semiring GxB_PLUS_LAND_FP32; +extern GrB_Semiring GxB_PLUS_LAND_FP64; +extern GrB_Semiring GxB_PLUS_LAND_INT8; +extern GrB_Semiring GxB_PLUS_LAND_INT16; +extern GrB_Semiring GxB_PLUS_LAND_INT32; +extern GrB_Semiring GxB_PLUS_LAND_INT64; +extern GrB_Semiring GxB_PLUS_LAND_UINT8; +extern GrB_Semiring GxB_PLUS_LAND_UINT16; +extern GrB_Semiring GxB_PLUS_LAND_UINT32; +extern GrB_Semiring GxB_PLUS_LAND_UINT64; +extern GrB_Semiring GxB_PLUS_LOR_FP32; +extern GrB_Semiring GxB_PLUS_LOR_FP64; +extern GrB_Semiring GxB_PLUS_LOR_INT8; +extern GrB_Semiring GxB_PLUS_LOR_INT16; +extern GrB_Semiring GxB_PLUS_LOR_INT32; +extern GrB_Semiring GxB_PLUS_LOR_INT64; +extern GrB_Semiring GxB_PLUS_LOR_UINT8; +extern GrB_Semiring GxB_PLUS_LOR_UINT16; +extern GrB_Semiring GxB_PLUS_LOR_UINT32; +extern GrB_Semiring GxB_PLUS_LOR_UINT64; +extern GrB_Semiring GxB_PLUS_LXOR_FP32; +extern GrB_Semiring GxB_PLUS_LXOR_FP64; +extern GrB_Semiring GxB_PLUS_LXOR_INT8; +extern GrB_Semiring GxB_PLUS_LXOR_INT16; +extern GrB_Semiring GxB_PLUS_LXOR_INT32; +extern GrB_Semiring GxB_PLUS_LXOR_INT64; +extern GrB_Semiring GxB_PLUS_LXOR_UINT8; +extern GrB_Semiring GxB_PLUS_LXOR_UINT16; +extern GrB_Semiring GxB_PLUS_LXOR_UINT32; +extern GrB_Semiring GxB_PLUS_LXOR_UINT64; +extern GrB_Semiring GxB_PLUS_MAX_FP32; +extern GrB_Semiring GxB_PLUS_MAX_FP64; +extern GrB_Semiring GxB_PLUS_MAX_INT8; +extern GrB_Semiring GxB_PLUS_MAX_INT16; +extern GrB_Semiring GxB_PLUS_MAX_INT32; +extern GrB_Semiring GxB_PLUS_MAX_INT64; +extern GrB_Semiring GxB_PLUS_MAX_UINT8; +extern GrB_Semiring GxB_PLUS_MAX_UINT16; +extern GrB_Semiring GxB_PLUS_MAX_UINT32; +extern GrB_Semiring GxB_PLUS_MAX_UINT64; +extern GrB_Semiring GxB_PLUS_MINUS_FC32; +extern GrB_Semiring GxB_PLUS_MINUS_FC64; +extern GrB_Semiring GxB_PLUS_MINUS_FP32; +extern GrB_Semiring GxB_PLUS_MINUS_FP64; +extern GrB_Semiring GxB_PLUS_MINUS_INT8; +extern GrB_Semiring GxB_PLUS_MINUS_INT16; +extern GrB_Semiring GxB_PLUS_MINUS_INT32; +extern GrB_Semiring GxB_PLUS_MINUS_INT64; +extern GrB_Semiring GxB_PLUS_MINUS_UINT8; +extern GrB_Semiring GxB_PLUS_MINUS_UINT16; +extern GrB_Semiring GxB_PLUS_MINUS_UINT32; +extern GrB_Semiring GxB_PLUS_MINUS_UINT64; +extern GrB_Semiring GxB_PLUS_PAIR_FC32; +extern GrB_Semiring GxB_PLUS_PAIR_FC64; +extern GrB_Semiring GxB_PLUS_PAIR_FP32; +extern GrB_Semiring GxB_PLUS_PAIR_FP64; +extern GrB_Semiring GxB_PLUS_PAIR_INT8; +extern GrB_Semiring GxB_PLUS_PAIR_INT16; +extern GrB_Semiring GxB_PLUS_PAIR_INT32; +extern GrB_Semiring GxB_PLUS_PAIR_INT64; +extern GrB_Semiring GxB_PLUS_PAIR_UINT8; +extern GrB_Semiring GxB_PLUS_PAIR_UINT16; +extern GrB_Semiring GxB_PLUS_PAIR_UINT32; +extern GrB_Semiring GxB_PLUS_PAIR_UINT64; +extern GrB_Semiring GxB_PLUS_PLUS_FC32; +extern GrB_Semiring GxB_PLUS_PLUS_FC64; +extern GrB_Semiring GxB_PLUS_PLUS_FP32; +extern GrB_Semiring GxB_PLUS_PLUS_FP64; +extern GrB_Semiring GxB_PLUS_PLUS_INT8; +extern GrB_Semiring GxB_PLUS_PLUS_INT16; +extern GrB_Semiring GxB_PLUS_PLUS_INT32; +extern GrB_Semiring GxB_PLUS_PLUS_INT64; +extern GrB_Semiring GxB_PLUS_PLUS_UINT8; +extern GrB_Semiring GxB_PLUS_PLUS_UINT16; +extern GrB_Semiring GxB_PLUS_PLUS_UINT32; +extern GrB_Semiring GxB_PLUS_PLUS_UINT64; +extern GrB_Semiring GxB_PLUS_RDIV_FC32; +extern GrB_Semiring GxB_PLUS_RDIV_FC64; +extern GrB_Semiring GxB_PLUS_RDIV_FP32; +extern GrB_Semiring GxB_PLUS_RDIV_FP64; +extern GrB_Semiring GxB_PLUS_RDIV_INT8; +extern GrB_Semiring GxB_PLUS_RDIV_INT16; +extern GrB_Semiring GxB_PLUS_RDIV_INT32; +extern GrB_Semiring GxB_PLUS_RDIV_INT64; +extern GrB_Semiring GxB_PLUS_RDIV_UINT8; +extern GrB_Semiring GxB_PLUS_RDIV_UINT16; +extern GrB_Semiring GxB_PLUS_RDIV_UINT32; +extern GrB_Semiring GxB_PLUS_RDIV_UINT64; +extern GrB_Semiring GxB_PLUS_RMINUS_FC32; +extern GrB_Semiring GxB_PLUS_RMINUS_FC64; +extern GrB_Semiring GxB_PLUS_RMINUS_FP32; +extern GrB_Semiring GxB_PLUS_RMINUS_FP64; +extern GrB_Semiring GxB_PLUS_RMINUS_INT8; +extern GrB_Semiring GxB_PLUS_RMINUS_INT16; +extern GrB_Semiring GxB_PLUS_RMINUS_INT32; +extern GrB_Semiring GxB_PLUS_RMINUS_INT64; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT8; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT16; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT32; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT64; +extern GrB_Semiring GxB_PLUS_SECONDI1_INT32; +extern GrB_Semiring GxB_PLUS_SECONDI1_INT64; +extern GrB_Semiring GxB_PLUS_SECONDI_INT32; +extern GrB_Semiring GxB_PLUS_SECONDI_INT64; +extern GrB_Semiring GxB_PLUS_SECONDJ1_INT32; +extern GrB_Semiring GxB_PLUS_SECONDJ1_INT64; +extern GrB_Semiring GxB_PLUS_SECONDJ_INT32; +extern GrB_Semiring GxB_PLUS_SECONDJ_INT64; +extern GrB_Semiring GxB_PLUS_SECOND_FC32; +extern GrB_Semiring GxB_PLUS_SECOND_FC64; +extern GrB_Semiring GxB_PLUS_SECOND_FP32; +extern GrB_Semiring GxB_PLUS_SECOND_FP64; +extern GrB_Semiring GxB_PLUS_SECOND_INT8; +extern GrB_Semiring GxB_PLUS_SECOND_INT16; +extern GrB_Semiring GxB_PLUS_SECOND_INT32; +extern GrB_Semiring GxB_PLUS_SECOND_INT64; +extern GrB_Semiring GxB_PLUS_SECOND_UINT8; +extern GrB_Semiring GxB_PLUS_SECOND_UINT16; +extern GrB_Semiring GxB_PLUS_SECOND_UINT32; +extern GrB_Semiring GxB_PLUS_SECOND_UINT64; +extern GrB_Semiring GxB_PLUS_TIMES_FC32; +extern GrB_Semiring GxB_PLUS_TIMES_FC64; +extern GrB_Semiring GxB_TIMES_DIV_FC32; +extern GrB_Semiring GxB_TIMES_DIV_FC64; +extern GrB_Semiring GxB_TIMES_DIV_FP32; +extern GrB_Semiring GxB_TIMES_DIV_FP64; +extern GrB_Semiring GxB_TIMES_DIV_INT8; +extern GrB_Semiring GxB_TIMES_DIV_INT16; +extern GrB_Semiring GxB_TIMES_DIV_INT32; +extern GrB_Semiring GxB_TIMES_DIV_INT64; +extern GrB_Semiring GxB_TIMES_DIV_UINT8; +extern GrB_Semiring GxB_TIMES_DIV_UINT16; +extern GrB_Semiring GxB_TIMES_DIV_UINT32; +extern GrB_Semiring GxB_TIMES_DIV_UINT64; +extern GrB_Semiring GxB_TIMES_FIRSTI1_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTI1_INT64; +extern GrB_Semiring GxB_TIMES_FIRSTI_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTI_INT64; +extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT64; +extern GrB_Semiring GxB_TIMES_FIRSTJ_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTJ_INT64; +extern GrB_Semiring GxB_TIMES_FIRST_FC32; +extern GrB_Semiring GxB_TIMES_FIRST_FC64; +extern GrB_Semiring GxB_TIMES_FIRST_FP32; +extern GrB_Semiring GxB_TIMES_FIRST_FP64; +extern GrB_Semiring GxB_TIMES_FIRST_INT8; +extern GrB_Semiring GxB_TIMES_FIRST_INT16; +extern GrB_Semiring GxB_TIMES_FIRST_INT32; +extern GrB_Semiring GxB_TIMES_FIRST_INT64; +extern GrB_Semiring GxB_TIMES_FIRST_UINT8; +extern GrB_Semiring GxB_TIMES_FIRST_UINT16; +extern GrB_Semiring GxB_TIMES_FIRST_UINT32; +extern GrB_Semiring GxB_TIMES_FIRST_UINT64; +extern GrB_Semiring GxB_TIMES_ISEQ_FP32; +extern GrB_Semiring GxB_TIMES_ISEQ_FP64; +extern GrB_Semiring GxB_TIMES_ISEQ_INT8; +extern GrB_Semiring GxB_TIMES_ISEQ_INT16; +extern GrB_Semiring GxB_TIMES_ISEQ_INT32; +extern GrB_Semiring GxB_TIMES_ISEQ_INT64; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT8; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT16; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT32; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT64; +extern GrB_Semiring GxB_TIMES_ISGE_FP32; +extern GrB_Semiring GxB_TIMES_ISGE_FP64; +extern GrB_Semiring GxB_TIMES_ISGE_INT8; +extern GrB_Semiring GxB_TIMES_ISGE_INT16; +extern GrB_Semiring GxB_TIMES_ISGE_INT32; +extern GrB_Semiring GxB_TIMES_ISGE_INT64; +extern GrB_Semiring GxB_TIMES_ISGE_UINT8; +extern GrB_Semiring GxB_TIMES_ISGE_UINT16; +extern GrB_Semiring GxB_TIMES_ISGE_UINT32; +extern GrB_Semiring GxB_TIMES_ISGE_UINT64; +extern GrB_Semiring GxB_TIMES_ISGT_FP32; +extern GrB_Semiring GxB_TIMES_ISGT_FP64; +extern GrB_Semiring GxB_TIMES_ISGT_INT8; +extern GrB_Semiring GxB_TIMES_ISGT_INT16; +extern GrB_Semiring GxB_TIMES_ISGT_INT32; +extern GrB_Semiring GxB_TIMES_ISGT_INT64; +extern GrB_Semiring GxB_TIMES_ISGT_UINT8; +extern GrB_Semiring GxB_TIMES_ISGT_UINT16; +extern GrB_Semiring GxB_TIMES_ISGT_UINT32; +extern GrB_Semiring GxB_TIMES_ISGT_UINT64; +extern GrB_Semiring GxB_TIMES_ISLE_FP32; +extern GrB_Semiring GxB_TIMES_ISLE_FP64; +extern GrB_Semiring GxB_TIMES_ISLE_INT8; +extern GrB_Semiring GxB_TIMES_ISLE_INT16; +extern GrB_Semiring GxB_TIMES_ISLE_INT32; +extern GrB_Semiring GxB_TIMES_ISLE_INT64; +extern GrB_Semiring GxB_TIMES_ISLE_UINT8; +extern GrB_Semiring GxB_TIMES_ISLE_UINT16; +extern GrB_Semiring GxB_TIMES_ISLE_UINT32; +extern GrB_Semiring GxB_TIMES_ISLE_UINT64; +extern GrB_Semiring GxB_TIMES_ISLT_FP32; +extern GrB_Semiring GxB_TIMES_ISLT_FP64; +extern GrB_Semiring GxB_TIMES_ISLT_INT8; +extern GrB_Semiring GxB_TIMES_ISLT_INT16; +extern GrB_Semiring GxB_TIMES_ISLT_INT32; +extern GrB_Semiring GxB_TIMES_ISLT_INT64; +extern GrB_Semiring GxB_TIMES_ISLT_UINT8; +extern GrB_Semiring GxB_TIMES_ISLT_UINT16; +extern GrB_Semiring GxB_TIMES_ISLT_UINT32; +extern GrB_Semiring GxB_TIMES_ISLT_UINT64; +extern GrB_Semiring GxB_TIMES_ISNE_FP32; +extern GrB_Semiring GxB_TIMES_ISNE_FP64; +extern GrB_Semiring GxB_TIMES_ISNE_INT8; +extern GrB_Semiring GxB_TIMES_ISNE_INT16; +extern GrB_Semiring GxB_TIMES_ISNE_INT32; +extern GrB_Semiring GxB_TIMES_ISNE_INT64; +extern GrB_Semiring GxB_TIMES_ISNE_UINT8; +extern GrB_Semiring GxB_TIMES_ISNE_UINT16; +extern GrB_Semiring GxB_TIMES_ISNE_UINT32; +extern GrB_Semiring GxB_TIMES_ISNE_UINT64; +extern GrB_Semiring GxB_TIMES_LAND_FP32; +extern GrB_Semiring GxB_TIMES_LAND_FP64; +extern GrB_Semiring GxB_TIMES_LAND_INT8; +extern GrB_Semiring GxB_TIMES_LAND_INT16; +extern GrB_Semiring GxB_TIMES_LAND_INT32; +extern GrB_Semiring GxB_TIMES_LAND_INT64; +extern GrB_Semiring GxB_TIMES_LAND_UINT8; +extern GrB_Semiring GxB_TIMES_LAND_UINT16; +extern GrB_Semiring GxB_TIMES_LAND_UINT32; +extern GrB_Semiring GxB_TIMES_LAND_UINT64; +extern GrB_Semiring GxB_TIMES_LOR_FP32; +extern GrB_Semiring GxB_TIMES_LOR_FP64; +extern GrB_Semiring GxB_TIMES_LOR_INT8; +extern GrB_Semiring GxB_TIMES_LOR_INT16; +extern GrB_Semiring GxB_TIMES_LOR_INT32; +extern GrB_Semiring GxB_TIMES_LOR_INT64; +extern GrB_Semiring GxB_TIMES_LOR_UINT8; +extern GrB_Semiring GxB_TIMES_LOR_UINT16; +extern GrB_Semiring GxB_TIMES_LOR_UINT32; +extern GrB_Semiring GxB_TIMES_LOR_UINT64; +extern GrB_Semiring GxB_TIMES_LXOR_FP32; +extern GrB_Semiring GxB_TIMES_LXOR_FP64; +extern GrB_Semiring GxB_TIMES_LXOR_INT8; +extern GrB_Semiring GxB_TIMES_LXOR_INT16; +extern GrB_Semiring GxB_TIMES_LXOR_INT32; +extern GrB_Semiring GxB_TIMES_LXOR_INT64; +extern GrB_Semiring GxB_TIMES_LXOR_UINT8; +extern GrB_Semiring GxB_TIMES_LXOR_UINT16; +extern GrB_Semiring GxB_TIMES_LXOR_UINT32; +extern GrB_Semiring GxB_TIMES_LXOR_UINT64; +extern GrB_Semiring GxB_TIMES_MAX_FP32; +extern GrB_Semiring GxB_TIMES_MAX_FP64; +extern GrB_Semiring GxB_TIMES_MAX_INT8; +extern GrB_Semiring GxB_TIMES_MAX_INT16; +extern GrB_Semiring GxB_TIMES_MAX_INT32; +extern GrB_Semiring GxB_TIMES_MAX_INT64; +extern GrB_Semiring GxB_TIMES_MAX_UINT8; +extern GrB_Semiring GxB_TIMES_MAX_UINT16; +extern GrB_Semiring GxB_TIMES_MAX_UINT32; +extern GrB_Semiring GxB_TIMES_MAX_UINT64; +extern GrB_Semiring GxB_TIMES_MINUS_FC32; +extern GrB_Semiring GxB_TIMES_MINUS_FC64; +extern GrB_Semiring GxB_TIMES_MINUS_FP32; +extern GrB_Semiring GxB_TIMES_MINUS_FP64; +extern GrB_Semiring GxB_TIMES_MINUS_INT8; +extern GrB_Semiring GxB_TIMES_MINUS_INT16; +extern GrB_Semiring GxB_TIMES_MINUS_INT32; +extern GrB_Semiring GxB_TIMES_MINUS_INT64; +extern GrB_Semiring GxB_TIMES_MINUS_UINT8; +extern GrB_Semiring GxB_TIMES_MINUS_UINT16; +extern GrB_Semiring GxB_TIMES_MINUS_UINT32; +extern GrB_Semiring GxB_TIMES_MINUS_UINT64; +extern GrB_Semiring GxB_TIMES_MIN_FP32; +extern GrB_Semiring GxB_TIMES_MIN_FP64; +extern GrB_Semiring GxB_TIMES_MIN_INT8; +extern GrB_Semiring GxB_TIMES_MIN_INT16; +extern GrB_Semiring GxB_TIMES_MIN_INT32; +extern GrB_Semiring GxB_TIMES_MIN_INT64; +extern GrB_Semiring GxB_TIMES_MIN_UINT8; +extern GrB_Semiring GxB_TIMES_MIN_UINT16; +extern GrB_Semiring GxB_TIMES_MIN_UINT32; +extern GrB_Semiring GxB_TIMES_MIN_UINT64; +extern GrB_Semiring GxB_TIMES_PAIR_FC32; +extern GrB_Semiring GxB_TIMES_PAIR_FC64; +extern GrB_Semiring GxB_TIMES_PAIR_FP32; +extern GrB_Semiring GxB_TIMES_PAIR_FP64; +extern GrB_Semiring GxB_TIMES_PAIR_INT8; +extern GrB_Semiring GxB_TIMES_PAIR_INT16; +extern GrB_Semiring GxB_TIMES_PAIR_INT32; +extern GrB_Semiring GxB_TIMES_PAIR_INT64; +extern GrB_Semiring GxB_TIMES_PAIR_UINT8; +extern GrB_Semiring GxB_TIMES_PAIR_UINT16; +extern GrB_Semiring GxB_TIMES_PAIR_UINT32; +extern GrB_Semiring GxB_TIMES_PAIR_UINT64; +extern GrB_Semiring GxB_TIMES_PLUS_FC32; +extern GrB_Semiring GxB_TIMES_PLUS_FC64; +extern GrB_Semiring GxB_TIMES_PLUS_FP32; +extern GrB_Semiring GxB_TIMES_PLUS_FP64; +extern GrB_Semiring GxB_TIMES_PLUS_INT8; +extern GrB_Semiring GxB_TIMES_PLUS_INT16; +extern GrB_Semiring GxB_TIMES_PLUS_INT32; +extern GrB_Semiring GxB_TIMES_PLUS_INT64; +extern GrB_Semiring GxB_TIMES_PLUS_UINT8; +extern GrB_Semiring GxB_TIMES_PLUS_UINT16; +extern GrB_Semiring GxB_TIMES_PLUS_UINT32; +extern GrB_Semiring GxB_TIMES_PLUS_UINT64; +extern GrB_Semiring GxB_TIMES_RDIV_FC32; +extern GrB_Semiring GxB_TIMES_RDIV_FC64; +extern GrB_Semiring GxB_TIMES_RDIV_FP32; +extern GrB_Semiring GxB_TIMES_RDIV_FP64; +extern GrB_Semiring GxB_TIMES_RDIV_INT8; +extern GrB_Semiring GxB_TIMES_RDIV_INT16; +extern GrB_Semiring GxB_TIMES_RDIV_INT32; +extern GrB_Semiring GxB_TIMES_RDIV_INT64; +extern GrB_Semiring GxB_TIMES_RDIV_UINT8; +extern GrB_Semiring GxB_TIMES_RDIV_UINT16; +extern GrB_Semiring GxB_TIMES_RDIV_UINT32; +extern GrB_Semiring GxB_TIMES_RDIV_UINT64; +extern GrB_Semiring GxB_TIMES_RMINUS_FC32; +extern GrB_Semiring GxB_TIMES_RMINUS_FC64; +extern GrB_Semiring GxB_TIMES_RMINUS_FP32; +extern GrB_Semiring GxB_TIMES_RMINUS_FP64; +extern GrB_Semiring GxB_TIMES_RMINUS_INT8; +extern GrB_Semiring GxB_TIMES_RMINUS_INT16; +extern GrB_Semiring GxB_TIMES_RMINUS_INT32; +extern GrB_Semiring GxB_TIMES_RMINUS_INT64; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT8; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT16; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT32; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT64; +extern GrB_Semiring GxB_TIMES_SECONDI1_INT32; +extern GrB_Semiring GxB_TIMES_SECONDI1_INT64; +extern GrB_Semiring GxB_TIMES_SECONDI_INT32; +extern GrB_Semiring GxB_TIMES_SECONDI_INT64; +extern GrB_Semiring GxB_TIMES_SECONDJ1_INT32; +extern GrB_Semiring GxB_TIMES_SECONDJ1_INT64; +extern GrB_Semiring GxB_TIMES_SECONDJ_INT32; +extern GrB_Semiring GxB_TIMES_SECONDJ_INT64; +extern GrB_Semiring GxB_TIMES_SECOND_FC32; +extern GrB_Semiring GxB_TIMES_SECOND_FC64; +extern GrB_Semiring GxB_TIMES_SECOND_FP32; +extern GrB_Semiring GxB_TIMES_SECOND_FP64; +extern GrB_Semiring GxB_TIMES_SECOND_INT8; +extern GrB_Semiring GxB_TIMES_SECOND_INT16; +extern GrB_Semiring GxB_TIMES_SECOND_INT32; +extern GrB_Semiring GxB_TIMES_SECOND_INT64; +extern GrB_Semiring GxB_TIMES_SECOND_UINT8; +extern GrB_Semiring GxB_TIMES_SECOND_UINT16; +extern GrB_Semiring GxB_TIMES_SECOND_UINT32; +extern GrB_Semiring GxB_TIMES_SECOND_UINT64; +extern GrB_Semiring GxB_TIMES_TIMES_FC32; +extern GrB_Semiring GxB_TIMES_TIMES_FC64; +extern GrB_Semiring GxB_TIMES_TIMES_FP32; +extern GrB_Semiring GxB_TIMES_TIMES_FP64; +extern GrB_Semiring GxB_TIMES_TIMES_INT8; +extern GrB_Semiring GxB_TIMES_TIMES_INT16; +extern GrB_Semiring GxB_TIMES_TIMES_INT32; +extern GrB_Semiring GxB_TIMES_TIMES_INT64; +extern GrB_Semiring GxB_TIMES_TIMES_UINT8; +extern GrB_Semiring GxB_TIMES_TIMES_UINT16; +extern GrB_Semiring GxB_TIMES_TIMES_UINT32; +extern GrB_Semiring GxB_TIMES_TIMES_UINT64; +extern GrB_Type GxB_FC32; +extern GrB_Type GxB_FC64; +extern GrB_UnaryOp GxB_ABS_FC32; +extern GrB_UnaryOp GxB_ABS_FC64; +extern GrB_UnaryOp GxB_ACOSH_FC32; +extern GrB_UnaryOp GxB_ACOSH_FC64; +extern GrB_UnaryOp GxB_ACOSH_FP32; +extern GrB_UnaryOp GxB_ACOSH_FP64; +extern GrB_UnaryOp GxB_ACOS_FC32; +extern GrB_UnaryOp GxB_ACOS_FC64; +extern GrB_UnaryOp GxB_ACOS_FP32; +extern GrB_UnaryOp GxB_ACOS_FP64; +extern GrB_UnaryOp GxB_AINV_FC32; +extern GrB_UnaryOp GxB_AINV_FC64; +extern GrB_UnaryOp GxB_ASINH_FC32; +extern GrB_UnaryOp GxB_ASINH_FC64; +extern GrB_UnaryOp GxB_ASINH_FP32; +extern GrB_UnaryOp GxB_ASINH_FP64; +extern GrB_UnaryOp GxB_ASIN_FC32; +extern GrB_UnaryOp GxB_ASIN_FC64; +extern GrB_UnaryOp GxB_ASIN_FP32; +extern GrB_UnaryOp GxB_ASIN_FP64; +extern GrB_UnaryOp GxB_ATANH_FC32; +extern GrB_UnaryOp GxB_ATANH_FC64; +extern GrB_UnaryOp GxB_ATANH_FP32; +extern GrB_UnaryOp GxB_ATANH_FP64; +extern GrB_UnaryOp GxB_ATAN_FC32; +extern GrB_UnaryOp GxB_ATAN_FC64; +extern GrB_UnaryOp GxB_ATAN_FP32; +extern GrB_UnaryOp GxB_ATAN_FP64; +extern GrB_UnaryOp GxB_CARG_FC32; +extern GrB_UnaryOp GxB_CARG_FC64; +extern GrB_UnaryOp GxB_CBRT_FP32; +extern GrB_UnaryOp GxB_CBRT_FP64; +extern GrB_UnaryOp GxB_CEIL_FC32; +extern GrB_UnaryOp GxB_CEIL_FC64; +extern GrB_UnaryOp GxB_CEIL_FP32; +extern GrB_UnaryOp GxB_CEIL_FP64; +extern GrB_UnaryOp GxB_CIMAG_FC32; +extern GrB_UnaryOp GxB_CIMAG_FC64; +extern GrB_UnaryOp GxB_CONJ_FC32; +extern GrB_UnaryOp GxB_CONJ_FC64; +extern GrB_UnaryOp GxB_COSH_FC32; +extern GrB_UnaryOp GxB_COSH_FC64; +extern GrB_UnaryOp GxB_COSH_FP32; +extern GrB_UnaryOp GxB_COSH_FP64; +extern GrB_UnaryOp GxB_COS_FC32; +extern GrB_UnaryOp GxB_COS_FC64; +extern GrB_UnaryOp GxB_COS_FP32; +extern GrB_UnaryOp GxB_COS_FP64; +extern GrB_UnaryOp GxB_CREAL_FC32; +extern GrB_UnaryOp GxB_CREAL_FC64; +extern GrB_UnaryOp GxB_ERFC_FP32; +extern GrB_UnaryOp GxB_ERFC_FP64; +extern GrB_UnaryOp GxB_ERF_FP32; +extern GrB_UnaryOp GxB_ERF_FP64; +extern GrB_UnaryOp GxB_EXP2_FC32; +extern GrB_UnaryOp GxB_EXP2_FC64; +extern GrB_UnaryOp GxB_EXP2_FP32; +extern GrB_UnaryOp GxB_EXP2_FP64; +extern GrB_UnaryOp GxB_EXPM1_FC32; +extern GrB_UnaryOp GxB_EXPM1_FC64; +extern GrB_UnaryOp GxB_EXPM1_FP32; +extern GrB_UnaryOp GxB_EXPM1_FP64; +extern GrB_UnaryOp GxB_EXP_FC32; +extern GrB_UnaryOp GxB_EXP_FC64; +extern GrB_UnaryOp GxB_EXP_FP32; +extern GrB_UnaryOp GxB_EXP_FP64; +extern GrB_UnaryOp GxB_FLOOR_FC32; +extern GrB_UnaryOp GxB_FLOOR_FC64; +extern GrB_UnaryOp GxB_FLOOR_FP32; +extern GrB_UnaryOp GxB_FLOOR_FP64; +extern GrB_UnaryOp GxB_FREXPE_FP32; +extern GrB_UnaryOp GxB_FREXPE_FP64; +extern GrB_UnaryOp GxB_FREXPX_FP32; +extern GrB_UnaryOp GxB_FREXPX_FP64; +extern GrB_UnaryOp GxB_IDENTITY_FC32; +extern GrB_UnaryOp GxB_IDENTITY_FC64; +extern GrB_UnaryOp GxB_ISFINITE_FC32; +extern GrB_UnaryOp GxB_ISFINITE_FC64; +extern GrB_UnaryOp GxB_ISFINITE_FP32; +extern GrB_UnaryOp GxB_ISFINITE_FP64; +extern GrB_UnaryOp GxB_ISINF_FC32; +extern GrB_UnaryOp GxB_ISINF_FC64; +extern GrB_UnaryOp GxB_ISINF_FP32; +extern GrB_UnaryOp GxB_ISINF_FP64; +extern GrB_UnaryOp GxB_ISNAN_FC32; +extern GrB_UnaryOp GxB_ISNAN_FC64; +extern GrB_UnaryOp GxB_ISNAN_FP32; +extern GrB_UnaryOp GxB_ISNAN_FP64; +extern GrB_UnaryOp GxB_LGAMMA_FP32; +extern GrB_UnaryOp GxB_LGAMMA_FP64; +extern GrB_UnaryOp GxB_LNOT_BOOL; +extern GrB_UnaryOp GxB_LNOT_FP32; +extern GrB_UnaryOp GxB_LNOT_FP64; +extern GrB_UnaryOp GxB_LNOT_INT8; +extern GrB_UnaryOp GxB_LNOT_INT16; +extern GrB_UnaryOp GxB_LNOT_INT32; +extern GrB_UnaryOp GxB_LNOT_INT64; +extern GrB_UnaryOp GxB_LNOT_UINT8; +extern GrB_UnaryOp GxB_LNOT_UINT16; +extern GrB_UnaryOp GxB_LNOT_UINT32; +extern GrB_UnaryOp GxB_LNOT_UINT64; +extern GrB_UnaryOp GxB_LOG10_FC32; +extern GrB_UnaryOp GxB_LOG10_FC64; +extern GrB_UnaryOp GxB_LOG10_FP32; +extern GrB_UnaryOp GxB_LOG10_FP64; +extern GrB_UnaryOp GxB_LOG1P_FC32; +extern GrB_UnaryOp GxB_LOG1P_FC64; +extern GrB_UnaryOp GxB_LOG1P_FP32; +extern GrB_UnaryOp GxB_LOG1P_FP64; +extern GrB_UnaryOp GxB_LOG2_FC32; +extern GrB_UnaryOp GxB_LOG2_FC64; +extern GrB_UnaryOp GxB_LOG2_FP32; +extern GrB_UnaryOp GxB_LOG2_FP64; +extern GrB_UnaryOp GxB_LOG_FC32; +extern GrB_UnaryOp GxB_LOG_FC64; +extern GrB_UnaryOp GxB_LOG_FP32; +extern GrB_UnaryOp GxB_LOG_FP64; +extern GrB_UnaryOp GxB_MINV_FC32; +extern GrB_UnaryOp GxB_MINV_FC64; +extern GrB_UnaryOp GxB_ONE_BOOL; +extern GrB_UnaryOp GxB_ONE_FC32; +extern GrB_UnaryOp GxB_ONE_FC64; +extern GrB_UnaryOp GxB_ONE_FP32; +extern GrB_UnaryOp GxB_ONE_FP64; +extern GrB_UnaryOp GxB_ONE_INT8; +extern GrB_UnaryOp GxB_ONE_INT16; +extern GrB_UnaryOp GxB_ONE_INT32; +extern GrB_UnaryOp GxB_ONE_INT64; +extern GrB_UnaryOp GxB_ONE_UINT8; +extern GrB_UnaryOp GxB_ONE_UINT16; +extern GrB_UnaryOp GxB_ONE_UINT32; +extern GrB_UnaryOp GxB_ONE_UINT64; +extern GrB_UnaryOp GxB_POSITIONI1_INT32; +extern GrB_UnaryOp GxB_POSITIONI1_INT64; +extern GrB_UnaryOp GxB_POSITIONI_INT32; +extern GrB_UnaryOp GxB_POSITIONI_INT64; +extern GrB_UnaryOp GxB_POSITIONJ1_INT32; +extern GrB_UnaryOp GxB_POSITIONJ1_INT64; +extern GrB_UnaryOp GxB_POSITIONJ_INT32; +extern GrB_UnaryOp GxB_POSITIONJ_INT64; +extern GrB_UnaryOp GxB_ROUND_FC32; +extern GrB_UnaryOp GxB_ROUND_FC64; +extern GrB_UnaryOp GxB_ROUND_FP32; +extern GrB_UnaryOp GxB_ROUND_FP64; +extern GrB_UnaryOp GxB_SIGNUM_FC32; +extern GrB_UnaryOp GxB_SIGNUM_FC64; +extern GrB_UnaryOp GxB_SIGNUM_FP32; +extern GrB_UnaryOp GxB_SIGNUM_FP64; +extern GrB_UnaryOp GxB_SINH_FC32; +extern GrB_UnaryOp GxB_SINH_FC64; +extern GrB_UnaryOp GxB_SINH_FP32; +extern GrB_UnaryOp GxB_SINH_FP64; +extern GrB_UnaryOp GxB_SIN_FC32; +extern GrB_UnaryOp GxB_SIN_FC64; +extern GrB_UnaryOp GxB_SIN_FP32; +extern GrB_UnaryOp GxB_SIN_FP64; +extern GrB_UnaryOp GxB_SQRT_FC32; +extern GrB_UnaryOp GxB_SQRT_FC64; +extern GrB_UnaryOp GxB_SQRT_FP32; +extern GrB_UnaryOp GxB_SQRT_FP64; +extern GrB_UnaryOp GxB_TANH_FC32; +extern GrB_UnaryOp GxB_TANH_FC64; +extern GrB_UnaryOp GxB_TANH_FP32; +extern GrB_UnaryOp GxB_TANH_FP64; +extern GrB_UnaryOp GxB_TAN_FC32; +extern GrB_UnaryOp GxB_TAN_FC64; +extern GrB_UnaryOp GxB_TAN_FP32; +extern GrB_UnaryOp GxB_TAN_FP64; +extern GrB_UnaryOp GxB_TGAMMA_FP32; +extern GrB_UnaryOp GxB_TGAMMA_FP64; +extern GrB_UnaryOp GxB_TRUNC_FC32; +extern GrB_UnaryOp GxB_TRUNC_FC64; +extern GrB_UnaryOp GxB_TRUNC_FP32; +extern GrB_UnaryOp GxB_TRUNC_FP64; + +/* GxB objects */ +extern GxB_Context GxB_CONTEXT_WORLD; +extern GxB_SelectOp GxB_DIAG; +extern GxB_SelectOp GxB_EQ_THUNK; +extern GxB_SelectOp GxB_EQ_ZERO; +extern GxB_SelectOp GxB_GE_THUNK; +extern GxB_SelectOp GxB_GE_ZERO; +extern GxB_SelectOp GxB_GT_THUNK; +extern GxB_SelectOp GxB_GT_ZERO; +extern GxB_SelectOp GxB_LE_THUNK; +extern GxB_SelectOp GxB_LE_ZERO; +extern GxB_SelectOp GxB_LT_THUNK; +extern GxB_SelectOp GxB_LT_ZERO; +extern GxB_SelectOp GxB_NE_THUNK; +extern GxB_SelectOp GxB_NONZERO; +extern GxB_SelectOp GxB_OFFDIAG; +extern GxB_SelectOp GxB_TRIL; +extern GxB_SelectOp GxB_TRIU; + +/**************** +* GrB functions * +****************/ + +/* binary */ +GrB_Info GrB_BinaryOp_error(const char **error, const GrB_BinaryOp object); +GrB_Info GrB_BinaryOp_free(GrB_BinaryOp *object); +GrB_Info GrB_BinaryOp_get_INT32(GrB_BinaryOp object, int32_t *, int); +GrB_Info GrB_BinaryOp_get_SIZE(GrB_BinaryOp object, size_t *, int); +GrB_Info GrB_BinaryOp_get_String(GrB_BinaryOp object, char *, int); +GrB_Info GrB_BinaryOp_get_VOID(GrB_BinaryOp object, void *, int); +GrB_Info GrB_BinaryOp_new(GrB_BinaryOp *binaryop, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); +GrB_Info GrB_BinaryOp_set_INT32(GrB_BinaryOp object, int32_t, int); +GrB_Info GrB_BinaryOp_set_String(GrB_BinaryOp object, char *, int); +GrB_Info GrB_BinaryOp_set_VOID(GrB_BinaryOp object, void *, int, size_t); +GrB_Info GrB_BinaryOp_wait(GrB_BinaryOp object, int waitmode); + +/* core */ +GrB_Info GrB_Global_get_INT32(GrB_Global object, int32_t *, int); +GrB_Info GrB_Global_get_SIZE(GrB_Global object, size_t *, int); +GrB_Info GrB_Global_get_String(GrB_Global object, char *, int); +GrB_Info GrB_Global_get_VOID(GrB_Global object, void *, int); +GrB_Info GrB_Global_set_INT32(GrB_Global object, int32_t, int); +GrB_Info GrB_Global_set_String(GrB_Global object, char *, int); +GrB_Info GrB_Global_set_VOID(GrB_Global object, void *, int, size_t); +GrB_Info GrB_finalize(void); +GrB_Info GrB_getVersion(unsigned int *, unsigned int *); +GrB_Info GrB_init(int mode); + +/* descriptor */ +GrB_Info GrB_Descriptor_error(const char **error, const GrB_Descriptor object); +GrB_Info GrB_Descriptor_free(GrB_Descriptor *object); +GrB_Info GrB_Descriptor_get_INT32(GrB_Descriptor object, int32_t *, int); +GrB_Info GrB_Descriptor_get_SIZE(GrB_Descriptor object, size_t *, int); +GrB_Info GrB_Descriptor_get_String(GrB_Descriptor object, char *, int); +GrB_Info GrB_Descriptor_get_VOID(GrB_Descriptor object, void *, int); +GrB_Info GrB_Descriptor_new(GrB_Descriptor *descriptor); +GrB_Info GrB_Descriptor_set(GrB_Descriptor, int, int); +GrB_Info GrB_Descriptor_set_INT32(GrB_Descriptor object, int32_t, int); +GrB_Info GrB_Descriptor_set_String(GrB_Descriptor object, char *, int); +GrB_Info GrB_Descriptor_set_VOID(GrB_Descriptor object, void *, int, size_t); +GrB_Info GrB_Descriptor_wait(GrB_Descriptor object, int waitmode); + +/* indexunary */ +GrB_Info GrB_IndexUnaryOp_error(const char **error, const GrB_IndexUnaryOp object); +GrB_Info GrB_IndexUnaryOp_free(GrB_IndexUnaryOp *object); +GrB_Info GrB_IndexUnaryOp_get_INT32(GrB_IndexUnaryOp object, int32_t *, int); +GrB_Info GrB_IndexUnaryOp_get_SIZE(GrB_IndexUnaryOp object, size_t *, int); +GrB_Info GrB_IndexUnaryOp_get_String(GrB_IndexUnaryOp object, char *, int); +GrB_Info GrB_IndexUnaryOp_get_VOID(GrB_IndexUnaryOp object, void *, int); +GrB_Info GrB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); +GrB_Info GrB_IndexUnaryOp_set_INT32(GrB_IndexUnaryOp object, int32_t, int); +GrB_Info GrB_IndexUnaryOp_set_String(GrB_IndexUnaryOp object, char *, int); +GrB_Info GrB_IndexUnaryOp_set_VOID(GrB_IndexUnaryOp object, void *, int, size_t); +GrB_Info GrB_IndexUnaryOp_wait(GrB_IndexUnaryOp object, int waitmode); + +/* matrix */ +GrB_Info GrB_Col_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GrB_Col_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Scalar x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_build_BOOL(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_FP32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_FP64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT8(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT16(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UDT(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT8(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT16(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_clear(GrB_Matrix A); +GrB_Info GrB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size); +GrB_Info GrB_Matrix_diag(GrB_Matrix *C, const GrB_Vector v, int64_t k); +GrB_Info GrB_Matrix_dup(GrB_Matrix *C, const GrB_Matrix A); +GrB_Info GrB_Matrix_eWiseAdd_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseAdd_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseAdd_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseMult_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseMult_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseMult_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_error(const char **error, const GrB_Matrix object); +GrB_Info GrB_Matrix_exportHint(int *format, GrB_Matrix A); +GrB_Info GrB_Matrix_exportSize(GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_BOOL(GrB_Index *Ap, GrB_Index *Ai, bool *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_FP32(GrB_Index *Ap, GrB_Index *Ai, float *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_FP64(GrB_Index *Ap, GrB_Index *Ai, double *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT8(GrB_Index *Ap, GrB_Index *Ai, int8_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT16(GrB_Index *Ap, GrB_Index *Ai, int16_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT32(GrB_Index *Ap, GrB_Index *Ai, int32_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT64(GrB_Index *Ap, GrB_Index *Ai, int64_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UDT(GrB_Index *Ap, GrB_Index *Ai, void *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT8(GrB_Index *Ap, GrB_Index *Ai, uint8_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT16(GrB_Index *Ap, GrB_Index *Ai, uint16_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT32(GrB_Index *Ap, GrB_Index *Ai, uint32_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT64(GrB_Index *Ap, GrB_Index *Ai, uint64_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_extract(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_extractElement_BOOL(bool *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_FP32(float *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_FP64(double *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT8(int8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT16(int16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT32(int32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT64(int64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_Scalar(GrB_Scalar x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UDT(void *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT8(uint8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT16(uint16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT32(uint32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT64(uint64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractTuples_BOOL(GrB_Index *I_, GrB_Index *J, bool *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_FP32(GrB_Index *I_, GrB_Index *J, float *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_FP64(GrB_Index *I_, GrB_Index *J, double *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT8(GrB_Index *I_, GrB_Index *J, int8_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT16(GrB_Index *I_, GrB_Index *J, int16_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT32(GrB_Index *I_, GrB_Index *J, int32_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT64(GrB_Index *I_, GrB_Index *J, int64_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UDT(GrB_Index *I_, GrB_Index *J, void *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT8(GrB_Index *I_, GrB_Index *J, uint8_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT16(GrB_Index *I_, GrB_Index *J, uint16_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT32(GrB_Index *I_, GrB_Index *J, uint32_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT64(GrB_Index *I_, GrB_Index *J, uint64_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_free(GrB_Matrix *object); +GrB_Info GrB_Matrix_get_INT32(GrB_Matrix object, int32_t *, int); +GrB_Info GrB_Matrix_get_SIZE(GrB_Matrix object, size_t *, int); +GrB_Info GrB_Matrix_get_Scalar(GrB_Matrix object, GrB_Scalar, int); +GrB_Info GrB_Matrix_get_String(GrB_Matrix object, char *, int); +GrB_Info GrB_Matrix_get_VOID(GrB_Matrix object, void *, int); +GrB_Info GrB_Matrix_import_BOOL(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const bool *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_FP32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const float *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_FP64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const double *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT8(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int8_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT16(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int16_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int32_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int64_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UDT(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const void *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT8(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint8_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT16(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint16_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint32_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint64_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_kronecker_BinaryOp(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_kronecker_Monoid(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_kronecker_Semiring(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_ncols(GrB_Index *ncols, const GrB_Matrix A); +GrB_Info GrB_Matrix_new(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols); +GrB_Info GrB_Matrix_nrows(GrB_Index *nrows, const GrB_Matrix A); +GrB_Info GrB_Matrix_nvals(GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_BinaryOp(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Matrix, const GrB_Descriptor); +GrB_Info GrB_Matrix_reduce_BinaryOp_Scalar(GrB_Scalar, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Matrix, const GrB_Descriptor); +GrB_Info GrB_Matrix_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_Monoid_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_removeElement(GrB_Matrix C, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_resize(GrB_Matrix C, GrB_Index nrows_new, GrB_Index ncols_new); +GrB_Info GrB_Matrix_select_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_serialize(void *blob, GrB_Index *blob_size, GrB_Matrix A); +GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size, GrB_Matrix A); +GrB_Info GrB_Matrix_setElement_BOOL(GrB_Matrix C, bool x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_FP32(GrB_Matrix C, float x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_FP64(GrB_Matrix C, double x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT8(GrB_Matrix C, int8_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT16(GrB_Matrix C, int16_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT32(GrB_Matrix C, int32_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT64(GrB_Matrix C, int64_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_Scalar(GrB_Matrix C, GrB_Scalar x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UDT(GrB_Matrix C, void *x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT8(GrB_Matrix C, uint8_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT16(GrB_Matrix C, uint16_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT32(GrB_Matrix C, uint32_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT64(GrB_Matrix C, uint64_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_set_INT32(GrB_Matrix object, int32_t, int); +GrB_Info GrB_Matrix_set_Scalar(GrB_Matrix object, GrB_Scalar, int); +GrB_Info GrB_Matrix_set_String(GrB_Matrix object, char *, int); +GrB_Info GrB_Matrix_set_VOID(GrB_Matrix object, void *, int, size_t); +GrB_Info GrB_Matrix_wait(GrB_Matrix object, int waitmode); +GrB_Info GrB_Row_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_mxm(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_mxv(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_transpose(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_vxm(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Matrix A, const GrB_Descriptor desc); + +/* monoid */ +GrB_Info GrB_Monoid_error(const char **error, const GrB_Monoid object); +GrB_Info GrB_Monoid_free(GrB_Monoid *object); +GrB_Info GrB_Monoid_get_INT32(GrB_Monoid object, int32_t *, int); +GrB_Info GrB_Monoid_get_SIZE(GrB_Monoid object, size_t *, int); +GrB_Info GrB_Monoid_get_String(GrB_Monoid object, char *, int); +GrB_Info GrB_Monoid_get_VOID(GrB_Monoid object, void *, int); +GrB_Info GrB_Monoid_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity); +GrB_Info GrB_Monoid_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity); +GrB_Info GrB_Monoid_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity); +GrB_Info GrB_Monoid_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity); +GrB_Info GrB_Monoid_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity); +GrB_Info GrB_Monoid_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity); +GrB_Info GrB_Monoid_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity); +GrB_Info GrB_Monoid_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity); +GrB_Info GrB_Monoid_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity); +GrB_Info GrB_Monoid_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity); +GrB_Info GrB_Monoid_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity); +GrB_Info GrB_Monoid_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity); +GrB_Info GrB_Monoid_set_INT32(GrB_Monoid object, int32_t, int); +GrB_Info GrB_Monoid_set_String(GrB_Monoid object, char *, int); +GrB_Info GrB_Monoid_set_VOID(GrB_Monoid object, void *, int, size_t); +GrB_Info GrB_Monoid_wait(GrB_Monoid object, int waitmode); + +/* scalar */ +GrB_Info GrB_BinaryOp_get_Scalar(GrB_BinaryOp object, GrB_Scalar, int); +GrB_Info GrB_BinaryOp_set_Scalar(GrB_BinaryOp object, GrB_Scalar, int); +GrB_Info GrB_Descriptor_get_Scalar(GrB_Descriptor object, GrB_Scalar, int); +GrB_Info GrB_Descriptor_set_Scalar(GrB_Descriptor object, GrB_Scalar, int); +GrB_Info GrB_Global_get_Scalar(GrB_Global object, GrB_Scalar, int); +GrB_Info GrB_Global_set_Scalar(GrB_Global object, GrB_Scalar, int); +GrB_Info GrB_IndexUnaryOp_get_Scalar(GrB_IndexUnaryOp object, GrB_Scalar, int); +GrB_Info GrB_IndexUnaryOp_set_Scalar(GrB_IndexUnaryOp object, GrB_Scalar, int); +GrB_Info GrB_Monoid_get_Scalar(GrB_Monoid object, GrB_Scalar, int); +GrB_Info GrB_Monoid_set_Scalar(GrB_Monoid object, GrB_Scalar, int); +GrB_Info GrB_Scalar_clear(GrB_Scalar s); +GrB_Info GrB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); +GrB_Info GrB_Scalar_error(const char **error, const GrB_Scalar object); +GrB_Info GrB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_free(GrB_Scalar *object); +GrB_Info GrB_Scalar_get_INT32(GrB_Scalar object, int32_t *, int); +GrB_Info GrB_Scalar_get_SIZE(GrB_Scalar object, size_t *, int); +GrB_Info GrB_Scalar_get_Scalar(GrB_Scalar object, GrB_Scalar, int); +GrB_Info GrB_Scalar_get_String(GrB_Scalar object, char *, int); +GrB_Info GrB_Scalar_get_VOID(GrB_Scalar object, void *, int); +GrB_Info GrB_Scalar_new(GrB_Scalar *s, GrB_Type type); +GrB_Info GrB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); +GrB_Info GrB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); +GrB_Info GrB_Scalar_setElement_FP32(GrB_Scalar s, float x); +GrB_Info GrB_Scalar_setElement_FP64(GrB_Scalar s, double x); +GrB_Info GrB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); +GrB_Info GrB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); +GrB_Info GrB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); +GrB_Info GrB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); +GrB_Info GrB_Scalar_setElement_UDT(GrB_Scalar s, void *x); +GrB_Info GrB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); +GrB_Info GrB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); +GrB_Info GrB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); +GrB_Info GrB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); +GrB_Info GrB_Scalar_set_INT32(GrB_Scalar object, int32_t, int); +GrB_Info GrB_Scalar_set_Scalar(GrB_Scalar object, GrB_Scalar, int); +GrB_Info GrB_Scalar_set_String(GrB_Scalar object, char *, int); +GrB_Info GrB_Scalar_set_VOID(GrB_Scalar object, void *, int, size_t); +GrB_Info GrB_Scalar_wait(GrB_Scalar object, int waitmode); +GrB_Info GrB_Semiring_get_Scalar(GrB_Semiring object, GrB_Scalar, int); +GrB_Info GrB_Semiring_set_Scalar(GrB_Semiring object, GrB_Scalar, int); +GrB_Info GrB_Type_get_Scalar(GrB_Type object, GrB_Scalar, int); +GrB_Info GrB_Type_set_Scalar(GrB_Type object, GrB_Scalar, int); +GrB_Info GrB_UnaryOp_get_Scalar(GrB_UnaryOp object, GrB_Scalar, int); +GrB_Info GrB_UnaryOp_set_Scalar(GrB_UnaryOp object, GrB_Scalar, int); + +/* semiring */ +GrB_Info GrB_Semiring_error(const char **error, const GrB_Semiring object); +GrB_Info GrB_Semiring_free(GrB_Semiring *object); +GrB_Info GrB_Semiring_get_INT32(GrB_Semiring object, int32_t *, int); +GrB_Info GrB_Semiring_get_SIZE(GrB_Semiring object, size_t *, int); +GrB_Info GrB_Semiring_get_String(GrB_Semiring object, char *, int); +GrB_Info GrB_Semiring_get_VOID(GrB_Semiring object, void *, int); +GrB_Info GrB_Semiring_new(GrB_Semiring *semiring, GrB_Monoid add, GrB_BinaryOp multiply); +GrB_Info GrB_Semiring_set_INT32(GrB_Semiring object, int32_t, int); +GrB_Info GrB_Semiring_set_String(GrB_Semiring object, char *, int); +GrB_Info GrB_Semiring_set_VOID(GrB_Semiring object, void *, int, size_t); +GrB_Info GrB_Semiring_wait(GrB_Semiring object, int waitmode); + +/* type */ +GrB_Info GrB_Type_error(const char **error, const GrB_Type object); +GrB_Info GrB_Type_free(GrB_Type *object); +GrB_Info GrB_Type_get_INT32(GrB_Type object, int32_t *, int); +GrB_Info GrB_Type_get_SIZE(GrB_Type object, size_t *, int); +GrB_Info GrB_Type_get_String(GrB_Type object, char *, int); +GrB_Info GrB_Type_get_VOID(GrB_Type object, void *, int); +GrB_Info GrB_Type_new(GrB_Type *type, size_t sizeof_ctype); +GrB_Info GrB_Type_set_INT32(GrB_Type object, int32_t, int); +GrB_Info GrB_Type_set_String(GrB_Type object, char *, int); +GrB_Info GrB_Type_set_VOID(GrB_Type object, void *, int, size_t); +GrB_Info GrB_Type_wait(GrB_Type object, int waitmode); + +/* unary */ +GrB_Info GrB_UnaryOp_error(const char **error, const GrB_UnaryOp object); +GrB_Info GrB_UnaryOp_free(GrB_UnaryOp *object); +GrB_Info GrB_UnaryOp_get_INT32(GrB_UnaryOp object, int32_t *, int); +GrB_Info GrB_UnaryOp_get_SIZE(GrB_UnaryOp object, size_t *, int); +GrB_Info GrB_UnaryOp_get_String(GrB_UnaryOp object, char *, int); +GrB_Info GrB_UnaryOp_get_VOID(GrB_UnaryOp object, void *, int); +GrB_Info GrB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype); +GrB_Info GrB_UnaryOp_set_INT32(GrB_UnaryOp object, int32_t, int); +GrB_Info GrB_UnaryOp_set_String(GrB_UnaryOp object, char *, int); +GrB_Info GrB_UnaryOp_set_VOID(GrB_UnaryOp object, void *, int, size_t); +GrB_Info GrB_UnaryOp_wait(GrB_UnaryOp object, int waitmode); + +/* vector */ +GrB_Info GrB_Vector_apply(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Scalar x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_build_BOOL(GrB_Vector w, const GrB_Index *I_, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_FP32(GrB_Vector w, const GrB_Index *I_, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_FP64(GrB_Vector w, const GrB_Index *I_, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT8(GrB_Vector w, const GrB_Index *I_, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT16(GrB_Vector w, const GrB_Index *I_, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT32(GrB_Vector w, const GrB_Index *I_, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT64(GrB_Vector w, const GrB_Index *I_, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UDT(GrB_Vector w, const GrB_Index *I_, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT8(GrB_Vector w, const GrB_Index *I_, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT16(GrB_Vector w, const GrB_Index *I_, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT32(GrB_Vector w, const GrB_Index *I_, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT64(GrB_Vector w, const GrB_Index *I_, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_clear(GrB_Vector v); +GrB_Info GrB_Vector_dup(GrB_Vector *w, const GrB_Vector u); +GrB_Info GrB_Vector_eWiseAdd_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseAdd_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseAdd_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseMult_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseMult_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseMult_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_error(const char **error, const GrB_Vector object); +GrB_Info GrB_Vector_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_extractElement_BOOL(bool *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_FP32(float *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_FP64(double *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT8(int8_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT16(int16_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT32(int32_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT64(int64_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_Scalar(GrB_Scalar x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UDT(void *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT8(uint8_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT16(uint16_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT32(uint32_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT64(uint64_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractTuples_BOOL(GrB_Index *I_, bool *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_FP32(GrB_Index *I_, float *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_FP64(GrB_Index *I_, double *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT8(GrB_Index *I_, int8_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT16(GrB_Index *I_, int16_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT32(GrB_Index *I_, int32_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT64(GrB_Index *I_, int64_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UDT(GrB_Index *I_, void *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT8(GrB_Index *I_, uint8_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT16(GrB_Index *I_, uint16_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT32(GrB_Index *I_, uint32_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT64(GrB_Index *I_, uint64_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_free(GrB_Vector *object); +GrB_Info GrB_Vector_get_INT32(GrB_Vector object, int32_t *, int); +GrB_Info GrB_Vector_get_SIZE(GrB_Vector object, size_t *, int); +GrB_Info GrB_Vector_get_Scalar(GrB_Vector object, GrB_Scalar, int); +GrB_Info GrB_Vector_get_String(GrB_Vector object, char *, int); +GrB_Info GrB_Vector_get_VOID(GrB_Vector object, void *, int); +GrB_Info GrB_Vector_new(GrB_Vector *v, GrB_Type type, GrB_Index n); +GrB_Info GrB_Vector_nvals(GrB_Index *nvals, const GrB_Vector v); +GrB_Info GrB_Vector_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_BinaryOp_Scalar(GrB_Scalar, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Vector, const GrB_Descriptor); +GrB_Info GrB_Vector_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_Monoid_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_removeElement(GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_resize(GrB_Vector w, GrB_Index nrows_new); +GrB_Info GrB_Vector_select_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_setElement_BOOL(GrB_Vector w, bool x, GrB_Index i); +GrB_Info GrB_Vector_setElement_FP32(GrB_Vector w, float x, GrB_Index i); +GrB_Info GrB_Vector_setElement_FP64(GrB_Vector w, double x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT8(GrB_Vector w, int8_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT16(GrB_Vector w, int16_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT32(GrB_Vector w, int32_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT64(GrB_Vector w, int64_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_Scalar(GrB_Vector w, GrB_Scalar x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UDT(GrB_Vector w, void *x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT8(GrB_Vector w, uint8_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT16(GrB_Vector w, uint16_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT32(GrB_Vector w, uint32_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT64(GrB_Vector w, uint64_t x, GrB_Index i); +GrB_Info GrB_Vector_set_INT32(GrB_Vector object, int32_t, int); +GrB_Info GrB_Vector_set_Scalar(GrB_Vector object, GrB_Scalar, int); +GrB_Info GrB_Vector_set_String(GrB_Vector object, char *, int); +GrB_Info GrB_Vector_set_VOID(GrB_Vector object, void *, int, size_t); +GrB_Info GrB_Vector_size(GrB_Index *n, const GrB_Vector v); +GrB_Info GrB_Vector_wait(GrB_Vector object, int waitmode); + +/*************** +* GB functions * +***************/ + +/* iterator */ +GrB_Info GB_Iterator_rc_bitmap_next(GxB_Iterator iterator); +GrB_Info GB_Iterator_rc_seek(GxB_Iterator iterator, GrB_Index j, bool jth_vector); +GrB_Info GB_Vector_Iterator_bitmap_seek(GxB_Iterator iterator); + +/* matrix */ +GrB_Info GB_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, int format, GrB_Descriptor desc); + +/**************** +* GxB functions * +****************/ + +/* binary */ +GrB_Info GxB_BinaryOp_fprint(GrB_BinaryOp binaryop, const char *name, int pr, FILE *f); +GrB_Info GxB_BinaryOp_new(GrB_BinaryOp *op, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *binop_name, const char *binop_defn); +GrB_Info GxB_BinaryOp_new_arena(GrB_BinaryOp *op_handle, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *binop_name, const char *binop_defn, const int header_arena); +GrB_Info GxB_BinaryOp_xtype(GrB_Type *, GrB_BinaryOp); +GrB_Info GxB_BinaryOp_xtype_name(char *, const GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ytype(GrB_Type *, GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ytype_name(char *, const GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ztype(GrB_Type *, GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ztype_name(char *, const GrB_BinaryOp); + +/* container */ +GrB_Info GxB_Container_free(GxB_Container *object); +GrB_Info GxB_Container_new(GxB_Container *Container); +GrB_Info GxB_Container_new_arena(GxB_Container *Container, const int header_arena, const int data_arena); + +/* context */ +GrB_Info GxB_Context_disengage(GxB_Context Context); +GrB_Info GxB_Context_engage(GxB_Context Context); +GrB_Info GxB_Context_error(const char **error, const GxB_Context object); +GrB_Info GxB_Context_fprint(GxB_Context Context, const char *name, int pr, FILE *f); +GrB_Info GxB_Context_free(GxB_Context *object); +GrB_Info GxB_Context_get(GxB_Context, int, ...); +GrB_Info GxB_Context_get_FP64(GxB_Context, int, double *); +GrB_Info GxB_Context_get_INT(GxB_Context, int32_t *, int); +GrB_Info GxB_Context_get_INT32(GxB_Context, int, int32_t *); +GrB_Info GxB_Context_get_SIZE(GxB_Context, size_t *, int); +GrB_Info GxB_Context_get_String(GxB_Context, char *, int); +GrB_Info GxB_Context_get_VOID(GxB_Context, void *, int); +GrB_Info GxB_Context_new(GxB_Context *Context); +GrB_Info GxB_Context_new_arena(GxB_Context *Context_handle, const int header_arena); +GrB_Info GxB_Context_set(GxB_Context, int, ...); +GrB_Info GxB_Context_set_FP64(GxB_Context, int, double); +GrB_Info GxB_Context_set_INT(GxB_Context, int32_t, int); +GrB_Info GxB_Context_set_INT32(GxB_Context, int, int32_t); +GrB_Info GxB_Context_set_String(GxB_Context, char *, int); +GrB_Info GxB_Context_set_VOID(GxB_Context, void *, int, size_t); +GrB_Info GxB_Context_wait(GxB_Context object, int waitmode); + +/* core */ +GrB_Info GxB_Global_Option_get(int, ...); +GrB_Info GxB_Global_Option_get_CHAR(int, const char **); +GrB_Info GxB_Global_Option_get_FP64(int, double *); +GrB_Info GxB_Global_Option_get_FUNCTION(int, void **); +GrB_Info GxB_Global_Option_get_INT32(int, int32_t *); +GrB_Info GxB_Global_Option_get_INT64(int, int64_t *); +GrB_Info GxB_Global_Option_set(int, ...); +GrB_Info GxB_Global_Option_set_CHAR(int, const char *); +GrB_Info GxB_Global_Option_set_FP64(int, double); +GrB_Info GxB_Global_Option_set_FP64_ARRAY(int, double *); +GrB_Info GxB_Global_Option_set_FUNCTION(int, void *); +GrB_Info GxB_Global_Option_set_INT32(int, int32_t); +GrB_Info GxB_Global_Option_set_INT64_ARRAY(int, int64_t *); +GrB_Info GxB_Serialized_get_INT32(const void *, int32_t *, int, size_t); +GrB_Info GxB_Serialized_get_SIZE(const void *, size_t *, int, size_t); +GrB_Info GxB_Serialized_get_String(const void *, char *, int, size_t); +GrB_Info GxB_Serialized_get_VOID(const void *, void *, int, size_t); +GrB_Info GxB_arena_init(int arena, void *(*user_malloc_function)(size_t), void *(*user_calloc_function)(size_t, size_t), void *(*user_realloc_function)(void *, size_t), void (*user_free_function)(void *)); +GrB_Info GxB_arena_initialized(int *flag, int arena); +GrB_Info GxB_deserialize_type_name(char *, const void *, uint64_t); +GrB_Info GxB_finalized(int *flag); +GrB_Info GxB_init(int mode, void *(*user_malloc_function)(size_t), void *(*user_calloc_function)(size_t, size_t), void *(*user_realloc_function)(void *, size_t), void (*user_free_function)(void *)); +GrB_Info GxB_initialized(int *flag); +void GxB_atfork_child(void); +void GxB_atfork_parent(void); +void GxB_atfork_prepare(void); + +/* descriptor */ +GrB_Info GxB_Desc_get(GrB_Descriptor, int, ...); +GrB_Info GxB_Desc_get_FP64(GrB_Descriptor, int, double *); +GrB_Info GxB_Desc_get_INT32(GrB_Descriptor, int, int32_t *); +GrB_Info GxB_Desc_set(GrB_Descriptor, int, ...); +GrB_Info GxB_Desc_set_FP64(GrB_Descriptor, int, double); +GrB_Info GxB_Desc_set_INT32(GrB_Descriptor, int, int32_t); +GrB_Info GxB_Descriptor_fprint(GrB_Descriptor descriptor, const char *name, int pr, FILE *f); +GrB_Info GxB_Descriptor_get(int32_t *, GrB_Descriptor, int); +GrB_Info GxB_Descriptor_new_arena(GrB_Descriptor *descriptor, const int header_arena); + +/* indexbinary */ +GrB_Info GxB_IndexBinaryOp_error(const char **error, const GxB_IndexBinaryOp object); +GrB_Info GxB_IndexBinaryOp_fprint(GxB_IndexBinaryOp op, const char *name, int pr, FILE *f); +GrB_Info GxB_IndexBinaryOp_free(GxB_IndexBinaryOp *object); +GrB_Info GxB_IndexBinaryOp_get_INT32(GxB_IndexBinaryOp object, int32_t *, int); +GrB_Info GxB_IndexBinaryOp_get_SIZE(GxB_IndexBinaryOp object, size_t *, int); +GrB_Info GxB_IndexBinaryOp_get_String(GxB_IndexBinaryOp object, char *, int); +GrB_Info GxB_IndexBinaryOp_get_VOID(GxB_IndexBinaryOp object, void *, int); +GrB_Info GxB_IndexBinaryOp_new(GxB_IndexBinaryOp *op, GxB_index_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, GrB_Type theta_type, const char *idxbinop_name, const char *idxbinop_defn); +GrB_Info GxB_IndexBinaryOp_new_arena(GxB_IndexBinaryOp *op_handle, GxB_index_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, GrB_Type theta_type, const char *idxop_name, const char *idxop_defn, const int header_arena); +GrB_Info GxB_IndexBinaryOp_set_INT32(GxB_IndexBinaryOp object, int32_t, int); +GrB_Info GxB_IndexBinaryOp_set_String(GxB_IndexBinaryOp object, char *, int); +GrB_Info GxB_IndexBinaryOp_set_VOID(GxB_IndexBinaryOp object, void *, int, size_t); +GrB_Info GxB_IndexBinaryOp_wait(GxB_IndexBinaryOp object, int waitmode); + +/* indexunary */ +GrB_Info GxB_IndexUnaryOp_fprint(GrB_IndexUnaryOp op, const char *name, int pr, FILE *f); +GrB_Info GxB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *idxop_name, const char *idxop_defn); +GrB_Info GxB_IndexUnaryOp_new_arena(GrB_IndexUnaryOp *op_handle, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *idxop_name, const char *idxop_defn, const int header_arena); +GrB_Info GxB_IndexUnaryOp_xtype_name(char *, const GrB_IndexUnaryOp); +GrB_Info GxB_IndexUnaryOp_ytype_name(char *, const GrB_IndexUnaryOp); +GrB_Info GxB_IndexUnaryOp_ztype_name(char *, const GrB_IndexUnaryOp); + +/* iterator */ +GrB_Index GxB_Matrix_Iterator_getp(GxB_Iterator iterator); +GrB_Index GxB_Matrix_Iterator_getpmax(GxB_Iterator iterator); +GrB_Index GxB_Vector_Iterator_getIndex(GxB_Iterator iterator); +GrB_Index GxB_Vector_Iterator_getp(GxB_Iterator iterator); +GrB_Index GxB_Vector_Iterator_getpmax(GxB_Iterator iterator); +GrB_Index GxB_colIterator_getColIndex(GxB_Iterator iterator); +GrB_Index GxB_colIterator_getRowIndex(GxB_Iterator iterator); +GrB_Index GxB_colIterator_kount(GxB_Iterator iterator); +GrB_Index GxB_rowIterator_getColIndex(GxB_Iterator iterator); +GrB_Index GxB_rowIterator_getRowIndex(GxB_Iterator iterator); +GrB_Index GxB_rowIterator_kount(GxB_Iterator iterator); +GrB_Info GxB_Iterator_free(GxB_Iterator *object); +GrB_Info GxB_Iterator_new(GxB_Iterator *iterator); +GrB_Info GxB_Iterator_new_arena(GxB_Iterator *iterator, const int header_arena); +GrB_Info GxB_Matrix_Iterator_next(GxB_Iterator iterator); +GrB_Info GxB_Matrix_Iterator_seek(GxB_Iterator iterator, GrB_Index p); +GrB_Info GxB_Vector_Iterator_next(GxB_Iterator iterator); +GrB_Info GxB_Vector_Iterator_seek(GxB_Iterator iterator, GrB_Index p); +GrB_Info GxB_colIterator_kseek(GxB_Iterator iterator, GrB_Index k); +GrB_Info GxB_colIterator_nextCol(GxB_Iterator iterator); +GrB_Info GxB_colIterator_nextRow(GxB_Iterator iterator); +GrB_Info GxB_colIterator_seekCol(GxB_Iterator iterator, GrB_Index col); +GrB_Info GxB_rowIterator_kseek(GxB_Iterator iterator, GrB_Index k); +GrB_Info GxB_rowIterator_nextCol(GxB_Iterator iterator); +GrB_Info GxB_rowIterator_nextRow(GxB_Iterator iterator); +GrB_Info GxB_rowIterator_seekRow(GxB_Iterator iterator, GrB_Index row); +GxB_FC32_t GxB_Iterator_get_FC32(GxB_Iterator iterator); +GxB_FC64_t GxB_Iterator_get_FC64(GxB_Iterator iterator); +bool GxB_Iterator_get_BOOL(GxB_Iterator iterator); +double GxB_Iterator_get_FP64(GxB_Iterator iterator); +float GxB_Iterator_get_FP32(GxB_Iterator iterator); +int8_t GxB_Iterator_get_INT8(GxB_Iterator iterator); +int16_t GxB_Iterator_get_INT16(GxB_Iterator iterator); +int32_t GxB_Iterator_get_INT32(GxB_Iterator iterator); +int64_t GxB_Iterator_get_INT64(GxB_Iterator iterator); +uint8_t GxB_Iterator_get_UINT8(GxB_Iterator iterator); +uint16_t GxB_Iterator_get_UINT16(GxB_Iterator iterator); +uint32_t GxB_Iterator_get_UINT32(GxB_Iterator iterator); +uint64_t GxB_Iterator_get_UINT64(GxB_Iterator iterator); +void GxB_Iterator_get_UDT(GxB_Iterator iterator, void *value); +void GxB_Matrix_Iterator_getIndex(GxB_Iterator iterator, GrB_Index *row, GrB_Index *col); + +/* matrix */ +GrB_Info GxB_Col_assign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Col_extract_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Col_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Col_subassign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); +GrB_Info GxB_Matrix_Option_get(GrB_Matrix, int, ...); +GrB_Info GxB_Matrix_Option_get_FP64(GrB_Matrix, int, double *); +GrB_Info GxB_Matrix_Option_get_INT32(GrB_Matrix, int, int32_t *); +GrB_Info GxB_Matrix_Option_set(GrB_Matrix, int, ...); +GrB_Info GxB_Matrix_Option_set_FP64(GrB_Matrix, int, double); +GrB_Info GxB_Matrix_Option_set_INT32(GrB_Matrix, int, int32_t); +GrB_Info GxB_Matrix_apply_BinaryOp1st(GrB_Matrix, const GrB_Matrix, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Scalar, const GrB_Matrix, const GrB_Descriptor); +GrB_Info GxB_Matrix_apply_BinaryOp1st_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC32_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_apply_BinaryOp1st_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC64_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_apply_BinaryOp2nd(GrB_Matrix, const GrB_Matrix, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Matrix, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Matrix_apply_BinaryOp2nd_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, GxB_FC32_t y, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_apply_BinaryOp2nd_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, GxB_FC64_t y, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_apply_IndexOp_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, GxB_FC32_t y, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_apply_IndexOp_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, GxB_FC64_t y, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_assign_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_assign_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_assign_Scalar_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_assign_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_build_FC32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const GxB_FC32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GxB_Matrix_build_FC64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const GxB_FC64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GxB_Matrix_build_Scalar(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, GrB_Scalar scalar, GrB_Index nvals); +GrB_Info GxB_Matrix_build_Scalar_Vector(GrB_Matrix C, const GrB_Vector I_vector, const GrB_Vector J_vector, GrB_Scalar scalar, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_build_Vector(GrB_Matrix C, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Vector X_vector, const GrB_BinaryOp dup, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_concat(GrB_Matrix C, const GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_deserialize_arena(GrB_Matrix *C, GrB_Type type, const void *blob, uint64_t blob_memsize, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_diag_arena(GrB_Matrix *C, const GrB_Vector v, int64_t k, const int header_arena, const int data_arena); +GrB_Info GxB_Matrix_dup_arena(GrB_Matrix *C, const GrB_Matrix A, const int header_arena, const int data_arena); +GrB_Info GxB_Matrix_eWiseUnion(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Matrix A, const GrB_Scalar alpha, const GrB_Matrix B, const GrB_Scalar beta, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_export_BitmapC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_BitmapR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_CSC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_CSR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_FC32(GrB_Index *Ap, GrB_Index *Ai, GxB_FC32_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GxB_Matrix_export_FC64(GrB_Index *Ap, GrB_Index *Ai, GxB_FC64_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GxB_Matrix_export_FullC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_FullR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_HyperCSC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_HyperCSR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_extractElement_FC32(GxB_FC32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GxB_Matrix_extractElement_FC64(GxB_FC64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GxB_Matrix_extractTuples_FC32(GrB_Index *I_, GrB_Index *J, GxB_FC32_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GxB_Matrix_extractTuples_FC64(GrB_Index *I_, GrB_Index *J, GxB_FC64_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GxB_Matrix_extractTuples_Vector(GrB_Vector I_vector, GrB_Vector J_vector, GrB_Vector X_vector, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_extract_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_fprint(GrB_Matrix A, const char *name, int pr, FILE *f); +GrB_Info GxB_Matrix_import_BitmapC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_BitmapR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_CSC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_CSR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_FC32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const GxB_FC32_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GxB_Matrix_import_FC64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const GxB_FC64_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GxB_Matrix_import_FullC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_FullR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_HyperCSC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_HyperCSR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_isStoredElement(const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GxB_Matrix_iso(bool *, const GrB_Matrix); +GrB_Info GxB_Matrix_memoryUsage(size_t *size, const GrB_Matrix A); +GrB_Info GxB_Matrix_new_arena(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const int header_arena, const int data_arena); +GrB_Info GxB_Matrix_pack_BitmapC(GrB_Matrix, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_BitmapR(GrB_Matrix, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_CSC(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_CSR(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_FullC(GrB_Matrix, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_FullR(GrB_Matrix, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_HyperCSC(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_HyperCSR(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_reduce_FC32(GxB_FC32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_reduce_FC64(GxB_FC64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_reshape(GrB_Matrix C, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_reshapeDup(GrB_Matrix *C, GrB_Matrix A, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_reshapeDup_arena(GrB_Matrix *C, GrB_Matrix A, bool by_col, uint64_t nrows_new, uint64_t ncols_new, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_select(GrB_Matrix, const GrB_Matrix, const GrB_BinaryOp, const GxB_SelectOp, const GrB_Matrix, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Matrix_select_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, GxB_FC32_t y, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_select_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, GxB_FC64_t y, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_serialize(void **blob_handle, GrB_Index *blob_size, GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_serialize_arena(void **blob_handle, GrB_Index *blob_size, GrB_Matrix A, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_setElement_FC32(GrB_Matrix C, GxB_FC32_t x, GrB_Index i, GrB_Index j); +GrB_Info GxB_Matrix_setElement_FC64(GrB_Matrix C, GxB_FC64_t x, GrB_Index i, GrB_Index j); +GrB_Info GxB_Matrix_set_arenas(GrB_Matrix *Ahandle, const int new_header_arena, const int new_data_arena); +GrB_Info GxB_Matrix_sort(GrB_Matrix C, GrB_Matrix P, GrB_BinaryOp op, GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_split(GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Index *Tile_nrows, const GrB_Index *Tile_ncols, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_split_arena(GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Index *Tile_nrows, const GrB_Index *Tile_ncols, const GrB_Matrix A, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_FC32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_FC64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_Scalar_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar scalar, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_type(GrB_Type *type, const GrB_Matrix A); +GrB_Info GxB_Matrix_type_name(char *, const GrB_Matrix); +GrB_Info GxB_Matrix_unpack_BitmapC(GrB_Matrix, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_BitmapR(GrB_Matrix, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_CSC(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_CSR(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_FullC(GrB_Matrix, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_FullR(GrB_Matrix, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_HyperCSC(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_HyperCSR(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Row_assign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Row_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Row_subassign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_diag(GrB_Vector v, const GrB_Matrix A, int64_t k, const GrB_Descriptor desc); +GrB_Info GxB_colIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); +GrB_Info GxB_load_Matrix_from_Container(GrB_Matrix A, GxB_Container Container, const GrB_Descriptor desc); +GrB_Info GxB_pack_HyperHash(GrB_Matrix, GrB_Matrix *, const GrB_Descriptor); +GrB_Info GxB_rowIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); +GrB_Info GxB_unload_Matrix_into_Container(GrB_Matrix A, GxB_Container Container, const GrB_Descriptor desc); +GrB_Info GxB_unpack_HyperHash(GrB_Matrix, GrB_Matrix *, const GrB_Descriptor); + +/* monoid */ +GrB_Info GxB_Monoid_fprint(GrB_Monoid monoid, const char *name, int pr, FILE *f); +GrB_Info GxB_Monoid_identity(void *, GrB_Monoid); +GrB_Info GxB_Monoid_new_FC32(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC32_t identity); +GrB_Info GxB_Monoid_new_FC64(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC64_t identity); +GrB_Info GxB_Monoid_new_arena_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_FC32(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC32_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_FC64(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC64_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, const int header_arena); +GrB_Info GxB_Monoid_operator(GrB_BinaryOp *, GrB_Monoid); +GrB_Info GxB_Monoid_terminal(bool *, void *, GrB_Monoid); +GrB_Info GxB_Monoid_terminal_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, bool terminal); +GrB_Info GxB_Monoid_terminal_new_FC32(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC32_t identity, GxB_FC32_t terminal); +GrB_Info GxB_Monoid_terminal_new_FC64(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC64_t identity, GxB_FC64_t terminal); +GrB_Info GxB_Monoid_terminal_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, float terminal); +GrB_Info GxB_Monoid_terminal_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, double terminal); +GrB_Info GxB_Monoid_terminal_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, int8_t terminal); +GrB_Info GxB_Monoid_terminal_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, int16_t terminal); +GrB_Info GxB_Monoid_terminal_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, int32_t terminal); +GrB_Info GxB_Monoid_terminal_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, int64_t terminal); +GrB_Info GxB_Monoid_terminal_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, void *terminal); +GrB_Info GxB_Monoid_terminal_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, uint8_t terminal); +GrB_Info GxB_Monoid_terminal_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, uint16_t terminal); +GrB_Info GxB_Monoid_terminal_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, uint32_t terminal); +GrB_Info GxB_Monoid_terminal_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, uint64_t terminal); +GrB_Info GxB_Monoid_terminal_new_arena_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, bool terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_FC32(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC32_t identity, GxB_FC32_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_FC64(GrB_Monoid *monoid, GrB_BinaryOp op, GxB_FC64_t identity, GxB_FC64_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, float terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, double terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, int8_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, int16_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, int32_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, int64_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, void *terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, uint8_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, uint16_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, uint32_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, uint64_t terminal, const int header_arena); + +/* scalar */ +GrB_Info GxB_BinaryOp_new_IndexOp(GrB_BinaryOp *binop, GxB_IndexBinaryOp idxbinop, GrB_Scalar theta); +GrB_Info GxB_BinaryOp_new_IndexOp_arena(GrB_BinaryOp *binop_handle, GxB_IndexBinaryOp idxbinop, GrB_Scalar theta, const int header_arena); +GrB_Info GxB_Context_get_Scalar(GxB_Context, GrB_Scalar, int); +GrB_Info GxB_Context_set_Scalar(GxB_Context, GrB_Scalar, int); +GrB_Info GxB_IndexBinaryOp_get_Scalar(GxB_IndexBinaryOp object, GrB_Scalar, int); +GrB_Info GxB_IndexBinaryOp_set_Scalar(GxB_IndexBinaryOp object, GrB_Scalar, int); +GrB_Info GxB_Scalar_clear(GrB_Scalar); +GrB_Info GxB_Scalar_dup(GrB_Scalar *, const GrB_Scalar); +GrB_Info GxB_Scalar_dup_arena(GrB_Scalar *s, const GrB_Scalar t, const int header_arena, const int data_arena); +GrB_Info GxB_Scalar_error(const char **, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_BOOL(bool *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_FC32(GxB_FC32_t *x, const GrB_Scalar s); +GrB_Info GxB_Scalar_extractElement_FC64(GxB_FC64_t *x, const GrB_Scalar s); +GrB_Info GxB_Scalar_extractElement_FP32(float *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_FP64(double *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT8(int8_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT16(int16_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT32(int32_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT64(int64_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UDT(void *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_fprint(GrB_Scalar s, const char *name, int pr, FILE *f); +GrB_Info GxB_Scalar_free(GrB_Scalar *); +GrB_Info GxB_Scalar_memoryUsage(size_t *size, const GrB_Scalar s); +GrB_Info GxB_Scalar_new(GrB_Scalar *, GrB_Type); +GrB_Info GxB_Scalar_new_arena(GrB_Scalar *s, GrB_Type type, const int header_arena, const int data_arena); +GrB_Info GxB_Scalar_nvals(uint64_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_setElement_BOOL(GrB_Scalar, bool); +GrB_Info GxB_Scalar_setElement_FC32(GrB_Scalar s, GxB_FC32_t x); +GrB_Info GxB_Scalar_setElement_FC64(GrB_Scalar s, GxB_FC64_t x); +GrB_Info GxB_Scalar_setElement_FP32(GrB_Scalar, float); +GrB_Info GxB_Scalar_setElement_FP64(GrB_Scalar, double); +GrB_Info GxB_Scalar_setElement_INT8(GrB_Scalar, int8_t); +GrB_Info GxB_Scalar_setElement_INT16(GrB_Scalar, int16_t); +GrB_Info GxB_Scalar_setElement_INT32(GrB_Scalar, int32_t); +GrB_Info GxB_Scalar_setElement_INT64(GrB_Scalar, int64_t); +GrB_Info GxB_Scalar_setElement_UDT(GrB_Scalar, void *); +GrB_Info GxB_Scalar_setElement_UINT8(GrB_Scalar, uint8_t); +GrB_Info GxB_Scalar_setElement_UINT16(GrB_Scalar, uint16_t); +GrB_Info GxB_Scalar_setElement_UINT32(GrB_Scalar, uint32_t); +GrB_Info GxB_Scalar_setElement_UINT64(GrB_Scalar, uint64_t); +GrB_Info GxB_Scalar_set_arenas(GrB_Scalar *Shandle, const int new_header_arena, const int new_data_arena); +GrB_Info GxB_Scalar_type(GrB_Type *type, const GrB_Scalar s); +GrB_Info GxB_Scalar_type_name(char *, const GrB_Scalar); +GrB_Info GxB_Scalar_wait(GrB_Scalar *); +GrB_Info GxB_Serialized_get_Scalar(const void *, GrB_Scalar, int, size_t); + +/* selectop */ +GrB_Info GxB_SelectOp_fprint(GxB_SelectOp, const char *, int, FILE *); +GrB_Info GxB_SelectOp_ttype(GrB_Type *, GxB_SelectOp); +GrB_Info GxB_SelectOp_xtype(GrB_Type *, GxB_SelectOp); + +/* semiring */ +GrB_Info GxB_Semiring_add(GrB_Monoid *, GrB_Semiring); +GrB_Info GxB_Semiring_fprint(GrB_Semiring semiring, const char *name, int pr, FILE *f); +GrB_Info GxB_Semiring_multiply(GrB_BinaryOp *, GrB_Semiring); +GrB_Info GxB_Semiring_new_arena(GrB_Semiring *semiring, GrB_Monoid add, GrB_BinaryOp multiply, const int header_arena); + +/* type */ +GrB_Info GxB_Type_fprint(GrB_Type type, const char *name, int pr, FILE *f); +GrB_Info GxB_Type_from_name(GrB_Type *type, const char *type_name); +GrB_Info GxB_Type_name(char *, const GrB_Type); +GrB_Info GxB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *type_name, const char *type_defn); +GrB_Info GxB_Type_new_arena(GrB_Type *type, size_t sizeof_type, const char *type_name, const char *type_defn, const int header_arena); +GrB_Info GxB_Type_size(size_t *, const GrB_Type); + +/* unary */ +GrB_Info GxB_UnaryOp_fprint(GrB_UnaryOp unaryop, const char *name, int pr, FILE *f); +GrB_Info GxB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn); +GrB_Info GxB_UnaryOp_new_arena(GrB_UnaryOp *op_handle, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn, const int header_arena); +GrB_Info GxB_UnaryOp_xtype(GrB_Type *, GrB_UnaryOp); +GrB_Info GxB_UnaryOp_xtype_name(char *, const GrB_UnaryOp); +GrB_Info GxB_UnaryOp_ztype(GrB_Type *, GrB_UnaryOp); +GrB_Info GxB_UnaryOp_ztype_name(char *, const GrB_UnaryOp); + +/* vector */ +GrB_Info GxB_Vector_Iterator_attach(GxB_Iterator iterator, GrB_Vector v, GrB_Descriptor desc); +GrB_Info GxB_Vector_Option_get(GrB_Vector, int, ...); +GrB_Info GxB_Vector_Option_get_FP64(GrB_Vector, int, double *); +GrB_Info GxB_Vector_Option_get_INT32(GrB_Vector, int, int32_t *); +GrB_Info GxB_Vector_Option_set(GrB_Vector, int, ...); +GrB_Info GxB_Vector_Option_set_FP64(GrB_Vector, int, double); +GrB_Info GxB_Vector_Option_set_INT32(GrB_Vector, int, int32_t); +GrB_Info GxB_Vector_apply_BinaryOp1st(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Scalar, const GrB_Vector, const GrB_Descriptor); +GrB_Info GxB_Vector_apply_BinaryOp1st_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC32_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_apply_BinaryOp1st_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, GxB_FC64_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_apply_BinaryOp2nd(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Vector, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Vector_apply_BinaryOp2nd_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, GxB_FC32_t y, const GrB_Descriptor desc); +GrB_Info GxB_Vector_apply_BinaryOp2nd_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, GxB_FC64_t y, const GrB_Descriptor desc); +GrB_Info GxB_Vector_apply_IndexOp_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, GxB_FC32_t y, const GrB_Descriptor desc); +GrB_Info GxB_Vector_apply_IndexOp_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, GxB_FC64_t y, const GrB_Descriptor desc); +GrB_Info GxB_Vector_assign_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_assign_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_assign_Scalar_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_assign_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_build_FC32(GrB_Vector w, const GrB_Index *I_, const GxB_FC32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GxB_Vector_build_FC64(GrB_Vector w, const GrB_Index *I_, const GxB_FC64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GxB_Vector_build_Scalar(GrB_Vector w, const GrB_Index *I_, const GrB_Scalar scalar, GrB_Index nvals); +GrB_Info GxB_Vector_build_Scalar_Vector(GrB_Vector w, const GrB_Vector I_vector, const GrB_Scalar scalar, const GrB_Descriptor desc); +GrB_Info GxB_Vector_build_Vector(GrB_Vector w, const GrB_Vector I_vector, const GrB_Vector X_vector, const GrB_BinaryOp dup, const GrB_Descriptor desc); +GrB_Info GxB_Vector_deserialize(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); +GrB_Info GxB_Vector_deserialize_arena(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Vector_dup_arena(GrB_Vector *w, const GrB_Vector u, const int header_arena, const int data_arena); +GrB_Info GxB_Vector_eWiseUnion(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Vector u, const GrB_Scalar alpha, const GrB_Vector v, const GrB_Scalar beta, const GrB_Descriptor desc); +GrB_Info GxB_Vector_export_Bitmap(GrB_Vector *, GrB_Type *, uint64_t *, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Vector_export_CSC(GrB_Vector *, GrB_Type *, uint64_t *, uint64_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Vector_export_Full(GrB_Vector *, GrB_Type *, uint64_t *, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Vector_extractElement_FC32(GxB_FC32_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GxB_Vector_extractElement_FC64(GxB_FC64_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GxB_Vector_extractTuples_FC32(GrB_Index *I_, GxB_FC32_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GxB_Vector_extractTuples_FC64(GrB_Index *I_, GxB_FC64_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GxB_Vector_extractTuples_Vector(GrB_Vector I_vector, GrB_Vector X_vector, const GrB_Vector V, const GrB_Descriptor desc); +GrB_Info GxB_Vector_extract_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_fprint(GrB_Vector v, const char *name, int pr, FILE *f); +GrB_Info GxB_Vector_import_Bitmap(GrB_Vector *, GrB_Type, uint64_t, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Vector_import_CSC(GrB_Vector *, GrB_Type, uint64_t, uint64_t **, void **, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_import_Full(GrB_Vector *, GrB_Type, uint64_t, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_isStoredElement(const GrB_Vector v, GrB_Index i); +GrB_Info GxB_Vector_iso(bool *, const GrB_Vector); +GrB_Info GxB_Vector_load(GrB_Vector V, void **X, GrB_Type type, uint64_t n, uint64_t X_memsize, int handling, const GrB_Descriptor desc); +GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); +GrB_Info GxB_Vector_new_arena(GrB_Vector *v, GrB_Type type, GrB_Index n, const int header_arena, const int data_arena); +GrB_Info GxB_Vector_pack_Bitmap(GrB_Vector, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Vector_pack_CSC(GrB_Vector, uint64_t **, void **, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_pack_Full(GrB_Vector, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_reduce_FC32(GxB_FC32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_reduce_FC64(GxB_FC64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_select(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GxB_SelectOp, const GrB_Vector, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Vector_select_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, GxB_FC32_t y, const GrB_Descriptor desc); +GrB_Info GxB_Vector_select_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, GxB_FC64_t y, const GrB_Descriptor desc); +GrB_Info GxB_Vector_serialize(void **blob_handle, GrB_Index *blob_size, GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_serialize_arena(void **blob_handle, GrB_Index *blob_size, GrB_Vector u, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Vector_setElement_FC32(GrB_Vector w, GxB_FC32_t x, GrB_Index i); +GrB_Info GxB_Vector_setElement_FC64(GrB_Vector w, GxB_FC64_t x, GrB_Index i); +GrB_Info GxB_Vector_set_arenas(GrB_Vector *Vhandle, const int new_header_arena, const int new_data_arena); +GrB_Info GxB_Vector_sort(GrB_Vector w, GrB_Vector p, GrB_BinaryOp op, GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_FC32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_FC64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GxB_FC64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_Scalar_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar scalar, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_type(GrB_Type *type, const GrB_Vector v); +GrB_Info GxB_Vector_type_name(char *, const GrB_Vector); +GrB_Info GxB_Vector_unload(GrB_Vector V, void **X, GrB_Type *type, uint64_t *n, uint64_t *X_memsize, int *handling, const GrB_Descriptor desc); +GrB_Info GxB_Vector_unpack_Bitmap(GrB_Vector, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Vector_unpack_CSC(GrB_Vector, uint64_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Vector_unpack_Full(GrB_Vector, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_load_Vector_from_Container(GrB_Vector V, GxB_Container Container, const GrB_Descriptor desc); +GrB_Info GxB_unload_Vector_into_Container(GrB_Vector V, GxB_Container Container, const GrB_Descriptor desc); + +/* int DEFINES */ +#define GRB_SUBVERSION ... +#define GRB_VERSION ... +#define GrB_INDEX_MAX ... +#define GxB_ANY_SPARSITY ... +#define GxB_ARENA_DATA ... +#define GxB_ARENA_HEADER ... +#define GxB_AUTO_SPARSITY ... +#define GxB_BACKWARDS ... +#define GxB_BEGIN ... +#define GxB_BITMAP ... +#define GxB_CHUNK ... +#define GxB_COMPRESSION_DEFAULT ... +#define GxB_COMPRESSION_LZ4 ... +#define GxB_COMPRESSION_LZ4HC ... +#define GxB_COMPRESSION_NONE ... +#define GxB_COMPRESSION_ZSTD ... +#define GxB_END ... +#define GxB_FAST_IMPORT ... +#define GxB_FULL ... +#define GxB_GPU_IDS ... +#define GxB_HYPERSPARSE ... +#define GxB_IMPLEMENTATION ... +#define GxB_IMPLEMENTATION_MAJOR ... +#define GxB_IMPLEMENTATION_MINOR ... +#define GxB_IMPLEMENTATION_SUB ... +#define GxB_INC ... +#define GxB_INDEX_MAX ... +#define GxB_MAX_NAME_LEN ... +#define GxB_NARENAS ... +#define GxB_NARENAS_GPU ... +#define GxB_NBITMAP_SWITCH ... +#define GxB_NGPUS ... +#define GxB_NTHREADS ... +#define GxB_RANGE ... +#define GxB_SPARSE ... +#define GxB_SPEC_MAJOR ... +#define GxB_SPEC_MINOR ... +#define GxB_SPEC_SUB ... +#define GxB_SPEC_VERSION ... +#define GxB_STDC_VERSION ... +#define GxB_STRIDE ... +#define GxB_USE_VALUES ... + +/* char* DEFINES */ +extern char *GxB_IMPLEMENTATION_ABOUT_STR; +extern char *GxB_IMPLEMENTATION_DATE_STR; +extern char *GxB_IMPLEMENTATION_LICENSE_STR; +extern char *GxB_IMPLEMENTATION_NAME_STR; +extern char *GxB_SPEC_ABOUT_STR; +extern char *GxB_SPEC_DATE_STR; diff --git a/suitesparse_graphblas/suitesparse_graphblas_no_complex.h b/suitesparse_graphblas/suitesparse_graphblas_no_complex.h new file mode 100644 index 0000000..9e80f31 --- /dev/null +++ b/suitesparse_graphblas/suitesparse_graphblas_no_complex.h @@ -0,0 +1,3624 @@ +/* This file is automatically generated */ +/* GrB typedefs */ +typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; +typedef struct GB_Descriptor_opaque *GrB_Descriptor; +typedef struct GB_Global_opaque *GrB_Global; +typedef struct GB_IndexUnaryOp_opaque *GrB_IndexUnaryOp; +typedef struct GB_Matrix_opaque *GrB_Matrix; +typedef struct GB_Monoid_opaque *GrB_Monoid; +typedef struct GB_Scalar_opaque *GrB_Scalar; +typedef struct GB_Semiring_opaque *GrB_Semiring; +typedef struct GB_Type_opaque *GrB_Type; +typedef struct GB_UnaryOp_opaque *GrB_UnaryOp; +typedef struct GB_Vector_opaque *GrB_Vector; +typedef uint64_t GrB_Index; + +/* GxB typedefs */ +typedef struct GB_Context_opaque *GxB_Context; +typedef struct GB_IndexBinaryOp_opaque *GxB_IndexBinaryOp; +typedef struct GB_Iterator_opaque *GxB_Iterator; +typedef struct GB_Scalar_opaque *GxB_Scalar; +typedef struct GB_SelectOp_opaque *GxB_SelectOp; +typedef struct GxB_Container_struct *GxB_Container; + +/* GxB typedefs (functions) */ +typedef int64_t (*GxB_print_function)(char *string, size_t string_len, const void *value, int verbose); +typedef void (*GxB_binary_function)(void *, const void *, const void *); +typedef void (*GxB_index_binary_function)(void *, const void *, GrB_Index, GrB_Index, const void *, GrB_Index, GrB_Index, const void *); +typedef void (*GxB_index_unary_function)(void *z, const void *x, GrB_Index i, GrB_Index j, const void *y); +typedef void (*GxB_unary_function)(void *, const void *); + +/* GxB structs */ +struct GxB_Container_struct +{ + uint64_t nrows; + uint64_t ncols; + int64_t nrows_nonempty; + int64_t ncols_nonempty; + uint64_t nvals; + uint64_t u64_future[11]; + int32_t format; + int32_t orientation; + int32_t header_arena; + uint32_t u32_future[13]; + GrB_Vector p; + GrB_Vector h; + GrB_Vector b; + GrB_Vector i; + GrB_Vector x; + GrB_Vector vector_future[11]; + GrB_Matrix Y; + GrB_Matrix matrix_future[15]; + bool iso; + bool jumbled; + bool bool_future[30]; + void *void_future[16]; +}; + +/* GrB enums */ +typedef enum +{ + GrB_OUTP = 0, + GrB_MASK = 1, + GrB_INP0 = 2, + GrB_INP1 = 3, + GxB_AxB_METHOD = 7090, + GxB_SORT = 7091, + GxB_COMPRESSION = 7092, + GxB_IMPORT = 7093, + GxB_ROWINDEX_LIST = 7094, + GxB_COLINDEX_LIST = 7095, + GxB_VALUE_LIST = 7096 +} GrB_Desc_Field; + +typedef enum +{ + GrB_DEFAULT = 0, + GxB_DEFAULT = 0, + GrB_REPLACE = 1, + GrB_COMP = 2, + GrB_STRUCTURE = 4, + GrB_COMP_STRUCTURE = 6, + GrB_TRAN = 3, + GxB_AxB_GUSTAVSON = 7081, + GxB_AxB_DOT = 7083, + GxB_AxB_HASH = 7084, + GxB_AxB_SAXPY = 7085, + GxB_SECURE_IMPORT = 7080, + GxB_USE_INDICES = 7060, + GxB_IS_STRIDE = 7061 +} GrB_Desc_Value; + +typedef enum +{ + GrB_CSR_FORMAT = 0, + GrB_CSC_FORMAT = 1, + GrB_COO_FORMAT = 2 +} GrB_Format; + +typedef enum +{ + GrB_SUCCESS = 0, + GrB_NO_VALUE = 1, + GxB_EXHAUSTED = 7089, + GrB_UNINITIALIZED_OBJECT = -1, + GrB_NULL_POINTER = -2, + GrB_INVALID_VALUE = -3, + GrB_INVALID_INDEX = -4, + GrB_DOMAIN_MISMATCH = -5, + GrB_DIMENSION_MISMATCH = -6, + GrB_OUTPUT_NOT_EMPTY = -7, + GrB_NOT_IMPLEMENTED = -8, + GrB_ALREADY_SET = -9, + GrB_PANIC = -101, + GrB_OUT_OF_MEMORY = -102, + GrB_INSUFFICIENT_SPACE = -103, + GrB_INVALID_OBJECT = -104, + GrB_INDEX_OUT_OF_BOUNDS = -105, + GrB_EMPTY_OBJECT = -106, + GxB_JIT_ERROR = -7001, + GxB_GPU_ERROR = -7002, + GxB_OUTPUT_IS_READONLY = -7003 +} GrB_Info; + +typedef enum +{ + GrB_NONBLOCKING = 0, + GrB_BLOCKING = 1 +} GrB_Mode; + +typedef enum +{ + GrB_ROWMAJOR = 0, + GrB_COLMAJOR = 1, + GrB_BOTH = 2, + GrB_UNKNOWN = 3 +} GrB_Orientation; + +typedef enum +{ + GrB_UDT_CODE = 0, + GrB_BOOL_CODE = 1, + GrB_INT8_CODE = 2, + GrB_UINT8_CODE = 3, + GrB_INT16_CODE = 4, + GrB_UINT16_CODE = 5, + GrB_INT32_CODE = 6, + GrB_UINT32_CODE = 7, + GrB_INT64_CODE = 8, + GrB_UINT64_CODE = 9, + GrB_FP32_CODE = 10, + GrB_FP64_CODE = 11 +} GrB_Type_Code; + +typedef enum +{ + GrB_COMPLETE = 0, + GrB_MATERIALIZE = 1 +} GrB_WaitMode; + +/* GxB enums */ +typedef enum +{ + GxB_CONTEXT_NTHREADS = 7086, + GxB_CONTEXT_CHUNK = 7087, + GxB_CONTEXT_NGPUS = 7102, + GxB_CONTEXT_GPU_IDS = 7101 +} GxB_Context_Field; + +typedef enum +{ + GxB_BY_ROW = 0, + GxB_BY_COL = 1, + GxB_NO_FORMAT = -1 +} GxB_Format_Value; + +typedef enum +{ + GxB_JIT_OFF = 0, + GxB_JIT_PAUSE = 1, + GxB_JIT_RUN = 2, + GxB_JIT_LOAD = 3, + GxB_JIT_ON = 4 +} GxB_JIT_Control; + +typedef enum +{ + GrB_OUTP_FIELD = 0, + GrB_MASK_FIELD = 1, + GrB_INP0_FIELD = 2, + GrB_INP1_FIELD = 3, + GrB_NAME = 10, + GrB_LIBRARY_VER_MAJOR = 11, + GrB_LIBRARY_VER_MINOR = 12, + GrB_LIBRARY_VER_PATCH = 13, + GrB_API_VER_MAJOR = 14, + GrB_API_VER_MINOR = 15, + GrB_API_VER_PATCH = 16, + GrB_BLOCKING_MODE = 17, + GrB_STORAGE_ORIENTATION_HINT = 100, + GrB_EL_TYPE_CODE = 102, + GrB_EL_TYPE_STRING = 106, + GrB_INP0_TYPE_CODE = 103, + GrB_INP1_TYPE_CODE = 104, + GrB_OUTP_TYPE_CODE = 105, + GrB_INP0_TYPE_STRING = 107, + GrB_INP1_TYPE_STRING = 108, + GrB_OUTP_TYPE_STRING = 109, + GrB_SIZE = 110, + GxB_JIT_C_NAME = 7041, + GxB_JIT_C_DEFINITION = 7042, + GxB_MONOID_IDENTITY = 7043, + GxB_MONOID_TERMINAL = 7044, + GxB_MONOID_OPERATOR = 7045, + GxB_SEMIRING_MONOID = 7046, + GxB_SEMIRING_MULTIPLY = 7047, + GxB_THETA_TYPE_CODE = 7050, + GxB_THETA_TYPE_STRING = 7051, + GxB_THETA = 7052, + GxB_ROWINDEX_INTEGER_HINT = 7053, + GxB_COLINDEX_INTEGER_HINT = 7054, + GxB_OFFSET_INTEGER_HINT = 7056, + GxB_HYPER_SWITCH = 7000, + GxB_HYPER_HASH = 7048, + GxB_BITMAP_SWITCH = 7001, + GxB_FORMAT = 7002, + GxB_ISO = 7079, + GxB_SPARSITY_CONTROL = 7036, + GxB_ROWINDEX_INTEGER_BITS = 7057, + GxB_COLINDEX_INTEGER_BITS = 7058, + GxB_OFFSET_INTEGER_BITS = 7059, + GxB_SPARSITY_STATUS = 7034, + GxB_IS_READONLY = 7078, + GxB_WILL_WAIT = 7076, + GxB_MODE = 7003, + GxB_LIBRARY_NAME = 7004, + GxB_LIBRARY_VERSION = 7005, + GxB_LIBRARY_DATE = 7006, + GxB_LIBRARY_ABOUT = 7007, + GxB_LIBRARY_URL = 7008, + GxB_LIBRARY_LICENSE = 7009, + GxB_LIBRARY_COMPILE_DATE = 7010, + GxB_LIBRARY_COMPILE_TIME = 7011, + GxB_API_VERSION = 7012, + GxB_API_DATE = 7013, + GxB_API_ABOUT = 7014, + GxB_API_URL = 7015, + GxB_COMPILER_VERSION = 7016, + GxB_COMPILER_NAME = 7017, + GxB_LIBRARY_OPENMP = 7018, + GxB_MALLOC_FUNCTION = 7037, + GxB_CALLOC_FUNCTION = 7038, + GxB_REALLOC_FUNCTION = 7039, + GxB_FREE_FUNCTION = 7040, + GxB_ARENA_MALLOC = 0x10000, + GxB_ARENA_CALLOC = 0x20000, + GxB_ARENA_REALLOC = 0x30000, + GxB_ARENA_FREE = 0x40000, + GxB_GLOBAL_NTHREADS = 7086, + GxB_GLOBAL_CHUNK = 7087, + GxB_GLOBAL_NGPUS = 7102, + GxB_GLOBAL_GPU_IDS = 7101, + GxB_NGPUS_MAX = 7103, + GxB_BURBLE = 7019, + GxB_PRINTF = 7020, + GxB_FLUSH = 7021, + GxB_MEMORY_POOL = 7022, + GxB_PRINT_1BASED = 7023, + GxB_INCLUDE_READONLY_STATISTICS = 7077, + GxB_JIT_C_COMPILER_NAME = 7024, + GxB_JIT_C_COMPILER_FLAGS = 7025, + GxB_JIT_C_LINKER_FLAGS = 7026, + GxB_JIT_C_LIBRARIES = 7027, + GxB_JIT_C_PREFACE = 7028, + GxB_JIT_C_CONTROL = 7029, + GxB_JIT_CACHE_PATH = 7030, + GxB_JIT_C_CMAKE_LIBS = 7031, + GxB_JIT_USE_CMAKE = 7032, + GxB_JIT_ERROR_LOG = 7033, + GxB_JIT_CUDA_PREFACE = 7100, + GxB_PRINT_FUNCTION = 7104 +} GxB_Option_Field; + +typedef enum +{ + GxB_SILENT = 0, + GxB_SUMMARY = 1, + GxB_SHORT = 2, + GxB_COMPLETE = 3, + GxB_SHORT_VERBOSE = 4, + GxB_COMPLETE_VERBOSE = 5 +} GxB_Print_Level; + +/* GrB consts */ +extern const GrB_Global GrB_GLOBAL; +extern const uint64_t *GrB_ALL; + +/* GxB consts */ +extern const double GxB_ALWAYS_HYPER; +extern const double GxB_HYPER_DEFAULT; +extern const double GxB_NEVER_HYPER; +extern const int GxB_FORMAT_DEFAULT; + +/* GrB objects */ +extern GrB_BinaryOp GrB_BAND_INT8; +extern GrB_BinaryOp GrB_BAND_INT16; +extern GrB_BinaryOp GrB_BAND_INT32; +extern GrB_BinaryOp GrB_BAND_INT64; +extern GrB_BinaryOp GrB_BAND_UINT8; +extern GrB_BinaryOp GrB_BAND_UINT16; +extern GrB_BinaryOp GrB_BAND_UINT32; +extern GrB_BinaryOp GrB_BAND_UINT64; +extern GrB_BinaryOp GrB_BOR_INT8; +extern GrB_BinaryOp GrB_BOR_INT16; +extern GrB_BinaryOp GrB_BOR_INT32; +extern GrB_BinaryOp GrB_BOR_INT64; +extern GrB_BinaryOp GrB_BOR_UINT8; +extern GrB_BinaryOp GrB_BOR_UINT16; +extern GrB_BinaryOp GrB_BOR_UINT32; +extern GrB_BinaryOp GrB_BOR_UINT64; +extern GrB_BinaryOp GrB_BXNOR_INT8; +extern GrB_BinaryOp GrB_BXNOR_INT16; +extern GrB_BinaryOp GrB_BXNOR_INT32; +extern GrB_BinaryOp GrB_BXNOR_INT64; +extern GrB_BinaryOp GrB_BXNOR_UINT8; +extern GrB_BinaryOp GrB_BXNOR_UINT16; +extern GrB_BinaryOp GrB_BXNOR_UINT32; +extern GrB_BinaryOp GrB_BXNOR_UINT64; +extern GrB_BinaryOp GrB_BXOR_INT8; +extern GrB_BinaryOp GrB_BXOR_INT16; +extern GrB_BinaryOp GrB_BXOR_INT32; +extern GrB_BinaryOp GrB_BXOR_INT64; +extern GrB_BinaryOp GrB_BXOR_UINT8; +extern GrB_BinaryOp GrB_BXOR_UINT16; +extern GrB_BinaryOp GrB_BXOR_UINT32; +extern GrB_BinaryOp GrB_BXOR_UINT64; +extern GrB_BinaryOp GrB_DIV_BOOL; +extern GrB_BinaryOp GrB_DIV_FP32; +extern GrB_BinaryOp GrB_DIV_FP64; +extern GrB_BinaryOp GrB_DIV_INT8; +extern GrB_BinaryOp GrB_DIV_INT16; +extern GrB_BinaryOp GrB_DIV_INT32; +extern GrB_BinaryOp GrB_DIV_INT64; +extern GrB_BinaryOp GrB_DIV_UINT8; +extern GrB_BinaryOp GrB_DIV_UINT16; +extern GrB_BinaryOp GrB_DIV_UINT32; +extern GrB_BinaryOp GrB_DIV_UINT64; +extern GrB_BinaryOp GrB_EQ_BOOL; +extern GrB_BinaryOp GrB_EQ_FP32; +extern GrB_BinaryOp GrB_EQ_FP64; +extern GrB_BinaryOp GrB_EQ_INT8; +extern GrB_BinaryOp GrB_EQ_INT16; +extern GrB_BinaryOp GrB_EQ_INT32; +extern GrB_BinaryOp GrB_EQ_INT64; +extern GrB_BinaryOp GrB_EQ_UINT8; +extern GrB_BinaryOp GrB_EQ_UINT16; +extern GrB_BinaryOp GrB_EQ_UINT32; +extern GrB_BinaryOp GrB_EQ_UINT64; +extern GrB_BinaryOp GrB_FIRST_BOOL; +extern GrB_BinaryOp GrB_FIRST_FP32; +extern GrB_BinaryOp GrB_FIRST_FP64; +extern GrB_BinaryOp GrB_FIRST_INT8; +extern GrB_BinaryOp GrB_FIRST_INT16; +extern GrB_BinaryOp GrB_FIRST_INT32; +extern GrB_BinaryOp GrB_FIRST_INT64; +extern GrB_BinaryOp GrB_FIRST_UINT8; +extern GrB_BinaryOp GrB_FIRST_UINT16; +extern GrB_BinaryOp GrB_FIRST_UINT32; +extern GrB_BinaryOp GrB_FIRST_UINT64; +extern GrB_BinaryOp GrB_GE_BOOL; +extern GrB_BinaryOp GrB_GE_FP32; +extern GrB_BinaryOp GrB_GE_FP64; +extern GrB_BinaryOp GrB_GE_INT8; +extern GrB_BinaryOp GrB_GE_INT16; +extern GrB_BinaryOp GrB_GE_INT32; +extern GrB_BinaryOp GrB_GE_INT64; +extern GrB_BinaryOp GrB_GE_UINT8; +extern GrB_BinaryOp GrB_GE_UINT16; +extern GrB_BinaryOp GrB_GE_UINT32; +extern GrB_BinaryOp GrB_GE_UINT64; +extern GrB_BinaryOp GrB_GT_BOOL; +extern GrB_BinaryOp GrB_GT_FP32; +extern GrB_BinaryOp GrB_GT_FP64; +extern GrB_BinaryOp GrB_GT_INT8; +extern GrB_BinaryOp GrB_GT_INT16; +extern GrB_BinaryOp GrB_GT_INT32; +extern GrB_BinaryOp GrB_GT_INT64; +extern GrB_BinaryOp GrB_GT_UINT8; +extern GrB_BinaryOp GrB_GT_UINT16; +extern GrB_BinaryOp GrB_GT_UINT32; +extern GrB_BinaryOp GrB_GT_UINT64; +extern GrB_BinaryOp GrB_LAND; +extern GrB_BinaryOp GrB_LE_BOOL; +extern GrB_BinaryOp GrB_LE_FP32; +extern GrB_BinaryOp GrB_LE_FP64; +extern GrB_BinaryOp GrB_LE_INT8; +extern GrB_BinaryOp GrB_LE_INT16; +extern GrB_BinaryOp GrB_LE_INT32; +extern GrB_BinaryOp GrB_LE_INT64; +extern GrB_BinaryOp GrB_LE_UINT8; +extern GrB_BinaryOp GrB_LE_UINT16; +extern GrB_BinaryOp GrB_LE_UINT32; +extern GrB_BinaryOp GrB_LE_UINT64; +extern GrB_BinaryOp GrB_LOR; +extern GrB_BinaryOp GrB_LT_BOOL; +extern GrB_BinaryOp GrB_LT_FP32; +extern GrB_BinaryOp GrB_LT_FP64; +extern GrB_BinaryOp GrB_LT_INT8; +extern GrB_BinaryOp GrB_LT_INT16; +extern GrB_BinaryOp GrB_LT_INT32; +extern GrB_BinaryOp GrB_LT_INT64; +extern GrB_BinaryOp GrB_LT_UINT8; +extern GrB_BinaryOp GrB_LT_UINT16; +extern GrB_BinaryOp GrB_LT_UINT32; +extern GrB_BinaryOp GrB_LT_UINT64; +extern GrB_BinaryOp GrB_LXNOR; +extern GrB_BinaryOp GrB_LXOR; +extern GrB_BinaryOp GrB_MAX_BOOL; +extern GrB_BinaryOp GrB_MAX_FP32; +extern GrB_BinaryOp GrB_MAX_FP64; +extern GrB_BinaryOp GrB_MAX_INT8; +extern GrB_BinaryOp GrB_MAX_INT16; +extern GrB_BinaryOp GrB_MAX_INT32; +extern GrB_BinaryOp GrB_MAX_INT64; +extern GrB_BinaryOp GrB_MAX_UINT8; +extern GrB_BinaryOp GrB_MAX_UINT16; +extern GrB_BinaryOp GrB_MAX_UINT32; +extern GrB_BinaryOp GrB_MAX_UINT64; +extern GrB_BinaryOp GrB_MINUS_BOOL; +extern GrB_BinaryOp GrB_MINUS_FP32; +extern GrB_BinaryOp GrB_MINUS_FP64; +extern GrB_BinaryOp GrB_MINUS_INT8; +extern GrB_BinaryOp GrB_MINUS_INT16; +extern GrB_BinaryOp GrB_MINUS_INT32; +extern GrB_BinaryOp GrB_MINUS_INT64; +extern GrB_BinaryOp GrB_MINUS_UINT8; +extern GrB_BinaryOp GrB_MINUS_UINT16; +extern GrB_BinaryOp GrB_MINUS_UINT32; +extern GrB_BinaryOp GrB_MINUS_UINT64; +extern GrB_BinaryOp GrB_MIN_BOOL; +extern GrB_BinaryOp GrB_MIN_FP32; +extern GrB_BinaryOp GrB_MIN_FP64; +extern GrB_BinaryOp GrB_MIN_INT8; +extern GrB_BinaryOp GrB_MIN_INT16; +extern GrB_BinaryOp GrB_MIN_INT32; +extern GrB_BinaryOp GrB_MIN_INT64; +extern GrB_BinaryOp GrB_MIN_UINT8; +extern GrB_BinaryOp GrB_MIN_UINT16; +extern GrB_BinaryOp GrB_MIN_UINT32; +extern GrB_BinaryOp GrB_MIN_UINT64; +extern GrB_BinaryOp GrB_NE_BOOL; +extern GrB_BinaryOp GrB_NE_FP32; +extern GrB_BinaryOp GrB_NE_FP64; +extern GrB_BinaryOp GrB_NE_INT8; +extern GrB_BinaryOp GrB_NE_INT16; +extern GrB_BinaryOp GrB_NE_INT32; +extern GrB_BinaryOp GrB_NE_INT64; +extern GrB_BinaryOp GrB_NE_UINT8; +extern GrB_BinaryOp GrB_NE_UINT16; +extern GrB_BinaryOp GrB_NE_UINT32; +extern GrB_BinaryOp GrB_NE_UINT64; +extern GrB_BinaryOp GrB_ONEB_BOOL; +extern GrB_BinaryOp GrB_ONEB_FP32; +extern GrB_BinaryOp GrB_ONEB_FP64; +extern GrB_BinaryOp GrB_ONEB_INT8; +extern GrB_BinaryOp GrB_ONEB_INT16; +extern GrB_BinaryOp GrB_ONEB_INT32; +extern GrB_BinaryOp GrB_ONEB_INT64; +extern GrB_BinaryOp GrB_ONEB_UINT8; +extern GrB_BinaryOp GrB_ONEB_UINT16; +extern GrB_BinaryOp GrB_ONEB_UINT32; +extern GrB_BinaryOp GrB_ONEB_UINT64; +extern GrB_BinaryOp GrB_PLUS_BOOL; +extern GrB_BinaryOp GrB_PLUS_FP32; +extern GrB_BinaryOp GrB_PLUS_FP64; +extern GrB_BinaryOp GrB_PLUS_INT8; +extern GrB_BinaryOp GrB_PLUS_INT16; +extern GrB_BinaryOp GrB_PLUS_INT32; +extern GrB_BinaryOp GrB_PLUS_INT64; +extern GrB_BinaryOp GrB_PLUS_UINT8; +extern GrB_BinaryOp GrB_PLUS_UINT16; +extern GrB_BinaryOp GrB_PLUS_UINT32; +extern GrB_BinaryOp GrB_PLUS_UINT64; +extern GrB_BinaryOp GrB_SECOND_BOOL; +extern GrB_BinaryOp GrB_SECOND_FP32; +extern GrB_BinaryOp GrB_SECOND_FP64; +extern GrB_BinaryOp GrB_SECOND_INT8; +extern GrB_BinaryOp GrB_SECOND_INT16; +extern GrB_BinaryOp GrB_SECOND_INT32; +extern GrB_BinaryOp GrB_SECOND_INT64; +extern GrB_BinaryOp GrB_SECOND_UINT8; +extern GrB_BinaryOp GrB_SECOND_UINT16; +extern GrB_BinaryOp GrB_SECOND_UINT32; +extern GrB_BinaryOp GrB_SECOND_UINT64; +extern GrB_BinaryOp GrB_TIMES_BOOL; +extern GrB_BinaryOp GrB_TIMES_FP32; +extern GrB_BinaryOp GrB_TIMES_FP64; +extern GrB_BinaryOp GrB_TIMES_INT8; +extern GrB_BinaryOp GrB_TIMES_INT16; +extern GrB_BinaryOp GrB_TIMES_INT32; +extern GrB_BinaryOp GrB_TIMES_INT64; +extern GrB_BinaryOp GrB_TIMES_UINT8; +extern GrB_BinaryOp GrB_TIMES_UINT16; +extern GrB_BinaryOp GrB_TIMES_UINT32; +extern GrB_BinaryOp GrB_TIMES_UINT64; +extern GrB_Descriptor GrB_DESC_C; +extern GrB_Descriptor GrB_DESC_CT0; +extern GrB_Descriptor GrB_DESC_CT0T1; +extern GrB_Descriptor GrB_DESC_CT1; +extern GrB_Descriptor GrB_DESC_R; +extern GrB_Descriptor GrB_DESC_RC; +extern GrB_Descriptor GrB_DESC_RCT0; +extern GrB_Descriptor GrB_DESC_RCT0T1; +extern GrB_Descriptor GrB_DESC_RCT1; +extern GrB_Descriptor GrB_DESC_RS; +extern GrB_Descriptor GrB_DESC_RSC; +extern GrB_Descriptor GrB_DESC_RSCT0; +extern GrB_Descriptor GrB_DESC_RSCT0T1; +extern GrB_Descriptor GrB_DESC_RSCT1; +extern GrB_Descriptor GrB_DESC_RST0; +extern GrB_Descriptor GrB_DESC_RST0T1; +extern GrB_Descriptor GrB_DESC_RST1; +extern GrB_Descriptor GrB_DESC_RT0; +extern GrB_Descriptor GrB_DESC_RT0T1; +extern GrB_Descriptor GrB_DESC_RT1; +extern GrB_Descriptor GrB_DESC_S; +extern GrB_Descriptor GrB_DESC_SC; +extern GrB_Descriptor GrB_DESC_SCT0; +extern GrB_Descriptor GrB_DESC_SCT0T1; +extern GrB_Descriptor GrB_DESC_SCT1; +extern GrB_Descriptor GrB_DESC_ST0; +extern GrB_Descriptor GrB_DESC_ST0T1; +extern GrB_Descriptor GrB_DESC_ST1; +extern GrB_Descriptor GrB_DESC_T0; +extern GrB_Descriptor GrB_DESC_T0T1; +extern GrB_Descriptor GrB_DESC_T1; +extern GrB_IndexUnaryOp GrB_COLGT; +extern GrB_IndexUnaryOp GrB_COLINDEX_INT32; +extern GrB_IndexUnaryOp GrB_COLINDEX_INT64; +extern GrB_IndexUnaryOp GrB_COLLE; +extern GrB_IndexUnaryOp GrB_DIAG; +extern GrB_IndexUnaryOp GrB_DIAGINDEX_INT32; +extern GrB_IndexUnaryOp GrB_DIAGINDEX_INT64; +extern GrB_IndexUnaryOp GrB_OFFDIAG; +extern GrB_IndexUnaryOp GrB_ROWGT; +extern GrB_IndexUnaryOp GrB_ROWINDEX_INT32; +extern GrB_IndexUnaryOp GrB_ROWINDEX_INT64; +extern GrB_IndexUnaryOp GrB_ROWLE; +extern GrB_IndexUnaryOp GrB_TRIL; +extern GrB_IndexUnaryOp GrB_TRIU; +extern GrB_IndexUnaryOp GrB_VALUEEQ_BOOL; +extern GrB_IndexUnaryOp GrB_VALUEEQ_FP32; +extern GrB_IndexUnaryOp GrB_VALUEEQ_FP64; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT8; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT16; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT32; +extern GrB_IndexUnaryOp GrB_VALUEEQ_INT64; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT8; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT16; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT32; +extern GrB_IndexUnaryOp GrB_VALUEEQ_UINT64; +extern GrB_IndexUnaryOp GrB_VALUEGE_BOOL; +extern GrB_IndexUnaryOp GrB_VALUEGE_FP32; +extern GrB_IndexUnaryOp GrB_VALUEGE_FP64; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT8; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT16; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT32; +extern GrB_IndexUnaryOp GrB_VALUEGE_INT64; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT8; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT16; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT32; +extern GrB_IndexUnaryOp GrB_VALUEGE_UINT64; +extern GrB_IndexUnaryOp GrB_VALUEGT_BOOL; +extern GrB_IndexUnaryOp GrB_VALUEGT_FP32; +extern GrB_IndexUnaryOp GrB_VALUEGT_FP64; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT8; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT16; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT32; +extern GrB_IndexUnaryOp GrB_VALUEGT_INT64; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT8; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT16; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT32; +extern GrB_IndexUnaryOp GrB_VALUEGT_UINT64; +extern GrB_IndexUnaryOp GrB_VALUELE_BOOL; +extern GrB_IndexUnaryOp GrB_VALUELE_FP32; +extern GrB_IndexUnaryOp GrB_VALUELE_FP64; +extern GrB_IndexUnaryOp GrB_VALUELE_INT8; +extern GrB_IndexUnaryOp GrB_VALUELE_INT16; +extern GrB_IndexUnaryOp GrB_VALUELE_INT32; +extern GrB_IndexUnaryOp GrB_VALUELE_INT64; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT8; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT16; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT32; +extern GrB_IndexUnaryOp GrB_VALUELE_UINT64; +extern GrB_IndexUnaryOp GrB_VALUELT_BOOL; +extern GrB_IndexUnaryOp GrB_VALUELT_FP32; +extern GrB_IndexUnaryOp GrB_VALUELT_FP64; +extern GrB_IndexUnaryOp GrB_VALUELT_INT8; +extern GrB_IndexUnaryOp GrB_VALUELT_INT16; +extern GrB_IndexUnaryOp GrB_VALUELT_INT32; +extern GrB_IndexUnaryOp GrB_VALUELT_INT64; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT8; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT16; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT32; +extern GrB_IndexUnaryOp GrB_VALUELT_UINT64; +extern GrB_IndexUnaryOp GrB_VALUENE_BOOL; +extern GrB_IndexUnaryOp GrB_VALUENE_FP32; +extern GrB_IndexUnaryOp GrB_VALUENE_FP64; +extern GrB_IndexUnaryOp GrB_VALUENE_INT8; +extern GrB_IndexUnaryOp GrB_VALUENE_INT16; +extern GrB_IndexUnaryOp GrB_VALUENE_INT32; +extern GrB_IndexUnaryOp GrB_VALUENE_INT64; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT8; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT16; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT32; +extern GrB_IndexUnaryOp GrB_VALUENE_UINT64; +extern GrB_Monoid GrB_LAND_MONOID_BOOL; +extern GrB_Monoid GrB_LOR_MONOID_BOOL; +extern GrB_Monoid GrB_LXNOR_MONOID_BOOL; +extern GrB_Monoid GrB_LXOR_MONOID_BOOL; +extern GrB_Monoid GrB_MAX_MONOID_FP32; +extern GrB_Monoid GrB_MAX_MONOID_FP64; +extern GrB_Monoid GrB_MAX_MONOID_INT8; +extern GrB_Monoid GrB_MAX_MONOID_INT16; +extern GrB_Monoid GrB_MAX_MONOID_INT32; +extern GrB_Monoid GrB_MAX_MONOID_INT64; +extern GrB_Monoid GrB_MAX_MONOID_UINT8; +extern GrB_Monoid GrB_MAX_MONOID_UINT16; +extern GrB_Monoid GrB_MAX_MONOID_UINT32; +extern GrB_Monoid GrB_MAX_MONOID_UINT64; +extern GrB_Monoid GrB_MIN_MONOID_FP32; +extern GrB_Monoid GrB_MIN_MONOID_FP64; +extern GrB_Monoid GrB_MIN_MONOID_INT8; +extern GrB_Monoid GrB_MIN_MONOID_INT16; +extern GrB_Monoid GrB_MIN_MONOID_INT32; +extern GrB_Monoid GrB_MIN_MONOID_INT64; +extern GrB_Monoid GrB_MIN_MONOID_UINT8; +extern GrB_Monoid GrB_MIN_MONOID_UINT16; +extern GrB_Monoid GrB_MIN_MONOID_UINT32; +extern GrB_Monoid GrB_MIN_MONOID_UINT64; +extern GrB_Monoid GrB_PLUS_MONOID_FP32; +extern GrB_Monoid GrB_PLUS_MONOID_FP64; +extern GrB_Monoid GrB_PLUS_MONOID_INT8; +extern GrB_Monoid GrB_PLUS_MONOID_INT16; +extern GrB_Monoid GrB_PLUS_MONOID_INT32; +extern GrB_Monoid GrB_PLUS_MONOID_INT64; +extern GrB_Monoid GrB_PLUS_MONOID_UINT8; +extern GrB_Monoid GrB_PLUS_MONOID_UINT16; +extern GrB_Monoid GrB_PLUS_MONOID_UINT32; +extern GrB_Monoid GrB_PLUS_MONOID_UINT64; +extern GrB_Monoid GrB_TIMES_MONOID_FP32; +extern GrB_Monoid GrB_TIMES_MONOID_FP64; +extern GrB_Monoid GrB_TIMES_MONOID_INT8; +extern GrB_Monoid GrB_TIMES_MONOID_INT16; +extern GrB_Monoid GrB_TIMES_MONOID_INT32; +extern GrB_Monoid GrB_TIMES_MONOID_INT64; +extern GrB_Monoid GrB_TIMES_MONOID_UINT8; +extern GrB_Monoid GrB_TIMES_MONOID_UINT16; +extern GrB_Monoid GrB_TIMES_MONOID_UINT32; +extern GrB_Monoid GrB_TIMES_MONOID_UINT64; +extern GrB_Semiring GrB_LAND_LOR_SEMIRING_BOOL; +extern GrB_Semiring GrB_LOR_LAND_SEMIRING_BOOL; +extern GrB_Semiring GrB_LXNOR_LOR_SEMIRING_BOOL; +extern GrB_Semiring GrB_LXOR_LAND_SEMIRING_BOOL; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_FIRST_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_MIN_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_PLUS_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_SECOND_SEMIRING_UINT64; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP32; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_FP64; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT8; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT16; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT32; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_INT64; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT8; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT16; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT32; +extern GrB_Semiring GrB_MAX_TIMES_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_FIRST_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_MAX_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_PLUS_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_SECOND_SEMIRING_UINT64; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP32; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_FP64; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT8; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT16; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT32; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_INT64; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT8; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT16; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT32; +extern GrB_Semiring GrB_MIN_TIMES_SEMIRING_UINT64; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP32; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_FP64; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT8; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT16; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT32; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_INT64; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT8; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT16; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT32; +extern GrB_Semiring GrB_PLUS_MIN_SEMIRING_UINT64; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP32; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_FP64; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT8; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT16; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT32; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_INT64; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT8; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT16; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT32; +extern GrB_Semiring GrB_PLUS_TIMES_SEMIRING_UINT64; +extern GrB_Type GrB_BOOL; +extern GrB_Type GrB_FP32; +extern GrB_Type GrB_FP64; +extern GrB_Type GrB_INT8; +extern GrB_Type GrB_INT16; +extern GrB_Type GrB_INT32; +extern GrB_Type GrB_INT64; +extern GrB_Type GrB_UINT8; +extern GrB_Type GrB_UINT16; +extern GrB_Type GrB_UINT32; +extern GrB_Type GrB_UINT64; +extern GrB_UnaryOp GrB_ABS_BOOL; +extern GrB_UnaryOp GrB_ABS_FP32; +extern GrB_UnaryOp GrB_ABS_FP64; +extern GrB_UnaryOp GrB_ABS_INT8; +extern GrB_UnaryOp GrB_ABS_INT16; +extern GrB_UnaryOp GrB_ABS_INT32; +extern GrB_UnaryOp GrB_ABS_INT64; +extern GrB_UnaryOp GrB_ABS_UINT8; +extern GrB_UnaryOp GrB_ABS_UINT16; +extern GrB_UnaryOp GrB_ABS_UINT32; +extern GrB_UnaryOp GrB_ABS_UINT64; +extern GrB_UnaryOp GrB_AINV_BOOL; +extern GrB_UnaryOp GrB_AINV_FP32; +extern GrB_UnaryOp GrB_AINV_FP64; +extern GrB_UnaryOp GrB_AINV_INT8; +extern GrB_UnaryOp GrB_AINV_INT16; +extern GrB_UnaryOp GrB_AINV_INT32; +extern GrB_UnaryOp GrB_AINV_INT64; +extern GrB_UnaryOp GrB_AINV_UINT8; +extern GrB_UnaryOp GrB_AINV_UINT16; +extern GrB_UnaryOp GrB_AINV_UINT32; +extern GrB_UnaryOp GrB_AINV_UINT64; +extern GrB_UnaryOp GrB_BNOT_INT8; +extern GrB_UnaryOp GrB_BNOT_INT16; +extern GrB_UnaryOp GrB_BNOT_INT32; +extern GrB_UnaryOp GrB_BNOT_INT64; +extern GrB_UnaryOp GrB_BNOT_UINT8; +extern GrB_UnaryOp GrB_BNOT_UINT16; +extern GrB_UnaryOp GrB_BNOT_UINT32; +extern GrB_UnaryOp GrB_BNOT_UINT64; +extern GrB_UnaryOp GrB_IDENTITY_BOOL; +extern GrB_UnaryOp GrB_IDENTITY_FP32; +extern GrB_UnaryOp GrB_IDENTITY_FP64; +extern GrB_UnaryOp GrB_IDENTITY_INT8; +extern GrB_UnaryOp GrB_IDENTITY_INT16; +extern GrB_UnaryOp GrB_IDENTITY_INT32; +extern GrB_UnaryOp GrB_IDENTITY_INT64; +extern GrB_UnaryOp GrB_IDENTITY_UINT8; +extern GrB_UnaryOp GrB_IDENTITY_UINT16; +extern GrB_UnaryOp GrB_IDENTITY_UINT32; +extern GrB_UnaryOp GrB_IDENTITY_UINT64; +extern GrB_UnaryOp GrB_LNOT; +extern GrB_UnaryOp GrB_MINV_BOOL; +extern GrB_UnaryOp GrB_MINV_FP32; +extern GrB_UnaryOp GrB_MINV_FP64; +extern GrB_UnaryOp GrB_MINV_INT8; +extern GrB_UnaryOp GrB_MINV_INT16; +extern GrB_UnaryOp GrB_MINV_INT32; +extern GrB_UnaryOp GrB_MINV_INT64; +extern GrB_UnaryOp GrB_MINV_UINT8; +extern GrB_UnaryOp GrB_MINV_UINT16; +extern GrB_UnaryOp GrB_MINV_UINT32; +extern GrB_UnaryOp GrB_MINV_UINT64; + +/* GrB objects (extended) */ +extern GrB_BinaryOp GxB_ANY_BOOL; +extern GrB_BinaryOp GxB_ANY_FP32; +extern GrB_BinaryOp GxB_ANY_FP64; +extern GrB_BinaryOp GxB_ANY_INT8; +extern GrB_BinaryOp GxB_ANY_INT16; +extern GrB_BinaryOp GxB_ANY_INT32; +extern GrB_BinaryOp GxB_ANY_INT64; +extern GrB_BinaryOp GxB_ANY_UINT8; +extern GrB_BinaryOp GxB_ANY_UINT16; +extern GrB_BinaryOp GxB_ANY_UINT32; +extern GrB_BinaryOp GxB_ANY_UINT64; +extern GrB_BinaryOp GxB_ATAN2_FP32; +extern GrB_BinaryOp GxB_ATAN2_FP64; +extern GrB_BinaryOp GxB_BCLR_INT8; +extern GrB_BinaryOp GxB_BCLR_INT16; +extern GrB_BinaryOp GxB_BCLR_INT32; +extern GrB_BinaryOp GxB_BCLR_INT64; +extern GrB_BinaryOp GxB_BCLR_UINT8; +extern GrB_BinaryOp GxB_BCLR_UINT16; +extern GrB_BinaryOp GxB_BCLR_UINT32; +extern GrB_BinaryOp GxB_BCLR_UINT64; +extern GrB_BinaryOp GxB_BGET_INT8; +extern GrB_BinaryOp GxB_BGET_INT16; +extern GrB_BinaryOp GxB_BGET_INT32; +extern GrB_BinaryOp GxB_BGET_INT64; +extern GrB_BinaryOp GxB_BGET_UINT8; +extern GrB_BinaryOp GxB_BGET_UINT16; +extern GrB_BinaryOp GxB_BGET_UINT32; +extern GrB_BinaryOp GxB_BGET_UINT64; +extern GrB_BinaryOp GxB_BSET_INT8; +extern GrB_BinaryOp GxB_BSET_INT16; +extern GrB_BinaryOp GxB_BSET_INT32; +extern GrB_BinaryOp GxB_BSET_INT64; +extern GrB_BinaryOp GxB_BSET_UINT8; +extern GrB_BinaryOp GxB_BSET_UINT16; +extern GrB_BinaryOp GxB_BSET_UINT32; +extern GrB_BinaryOp GxB_BSET_UINT64; +extern GrB_BinaryOp GxB_BSHIFT_INT8; +extern GrB_BinaryOp GxB_BSHIFT_INT16; +extern GrB_BinaryOp GxB_BSHIFT_INT32; +extern GrB_BinaryOp GxB_BSHIFT_INT64; +extern GrB_BinaryOp GxB_BSHIFT_UINT8; +extern GrB_BinaryOp GxB_BSHIFT_UINT16; +extern GrB_BinaryOp GxB_BSHIFT_UINT32; +extern GrB_BinaryOp GxB_BSHIFT_UINT64; +extern GrB_BinaryOp GxB_CMPLX_FP32; +extern GrB_BinaryOp GxB_CMPLX_FP64; +extern GrB_BinaryOp GxB_COPYSIGN_FP32; +extern GrB_BinaryOp GxB_COPYSIGN_FP64; +extern GrB_BinaryOp GxB_FIRSTI1_INT32; +extern GrB_BinaryOp GxB_FIRSTI1_INT64; +extern GrB_BinaryOp GxB_FIRSTI_INT32; +extern GrB_BinaryOp GxB_FIRSTI_INT64; +extern GrB_BinaryOp GxB_FIRSTJ1_INT32; +extern GrB_BinaryOp GxB_FIRSTJ1_INT64; +extern GrB_BinaryOp GxB_FIRSTJ_INT32; +extern GrB_BinaryOp GxB_FIRSTJ_INT64; +extern GrB_BinaryOp GxB_FMOD_FP32; +extern GrB_BinaryOp GxB_FMOD_FP64; +extern GrB_BinaryOp GxB_HYPOT_FP32; +extern GrB_BinaryOp GxB_HYPOT_FP64; +extern GrB_BinaryOp GxB_IGNORE_DUP; +extern GrB_BinaryOp GxB_ISEQ_BOOL; +extern GrB_BinaryOp GxB_ISEQ_FP32; +extern GrB_BinaryOp GxB_ISEQ_FP64; +extern GrB_BinaryOp GxB_ISEQ_INT8; +extern GrB_BinaryOp GxB_ISEQ_INT16; +extern GrB_BinaryOp GxB_ISEQ_INT32; +extern GrB_BinaryOp GxB_ISEQ_INT64; +extern GrB_BinaryOp GxB_ISEQ_UINT8; +extern GrB_BinaryOp GxB_ISEQ_UINT16; +extern GrB_BinaryOp GxB_ISEQ_UINT32; +extern GrB_BinaryOp GxB_ISEQ_UINT64; +extern GrB_BinaryOp GxB_ISGE_BOOL; +extern GrB_BinaryOp GxB_ISGE_FP32; +extern GrB_BinaryOp GxB_ISGE_FP64; +extern GrB_BinaryOp GxB_ISGE_INT8; +extern GrB_BinaryOp GxB_ISGE_INT16; +extern GrB_BinaryOp GxB_ISGE_INT32; +extern GrB_BinaryOp GxB_ISGE_INT64; +extern GrB_BinaryOp GxB_ISGE_UINT8; +extern GrB_BinaryOp GxB_ISGE_UINT16; +extern GrB_BinaryOp GxB_ISGE_UINT32; +extern GrB_BinaryOp GxB_ISGE_UINT64; +extern GrB_BinaryOp GxB_ISGT_BOOL; +extern GrB_BinaryOp GxB_ISGT_FP32; +extern GrB_BinaryOp GxB_ISGT_FP64; +extern GrB_BinaryOp GxB_ISGT_INT8; +extern GrB_BinaryOp GxB_ISGT_INT16; +extern GrB_BinaryOp GxB_ISGT_INT32; +extern GrB_BinaryOp GxB_ISGT_INT64; +extern GrB_BinaryOp GxB_ISGT_UINT8; +extern GrB_BinaryOp GxB_ISGT_UINT16; +extern GrB_BinaryOp GxB_ISGT_UINT32; +extern GrB_BinaryOp GxB_ISGT_UINT64; +extern GrB_BinaryOp GxB_ISLE_BOOL; +extern GrB_BinaryOp GxB_ISLE_FP32; +extern GrB_BinaryOp GxB_ISLE_FP64; +extern GrB_BinaryOp GxB_ISLE_INT8; +extern GrB_BinaryOp GxB_ISLE_INT16; +extern GrB_BinaryOp GxB_ISLE_INT32; +extern GrB_BinaryOp GxB_ISLE_INT64; +extern GrB_BinaryOp GxB_ISLE_UINT8; +extern GrB_BinaryOp GxB_ISLE_UINT16; +extern GrB_BinaryOp GxB_ISLE_UINT32; +extern GrB_BinaryOp GxB_ISLE_UINT64; +extern GrB_BinaryOp GxB_ISLT_BOOL; +extern GrB_BinaryOp GxB_ISLT_FP32; +extern GrB_BinaryOp GxB_ISLT_FP64; +extern GrB_BinaryOp GxB_ISLT_INT8; +extern GrB_BinaryOp GxB_ISLT_INT16; +extern GrB_BinaryOp GxB_ISLT_INT32; +extern GrB_BinaryOp GxB_ISLT_INT64; +extern GrB_BinaryOp GxB_ISLT_UINT8; +extern GrB_BinaryOp GxB_ISLT_UINT16; +extern GrB_BinaryOp GxB_ISLT_UINT32; +extern GrB_BinaryOp GxB_ISLT_UINT64; +extern GrB_BinaryOp GxB_ISNE_BOOL; +extern GrB_BinaryOp GxB_ISNE_FP32; +extern GrB_BinaryOp GxB_ISNE_FP64; +extern GrB_BinaryOp GxB_ISNE_INT8; +extern GrB_BinaryOp GxB_ISNE_INT16; +extern GrB_BinaryOp GxB_ISNE_INT32; +extern GrB_BinaryOp GxB_ISNE_INT64; +extern GrB_BinaryOp GxB_ISNE_UINT8; +extern GrB_BinaryOp GxB_ISNE_UINT16; +extern GrB_BinaryOp GxB_ISNE_UINT32; +extern GrB_BinaryOp GxB_ISNE_UINT64; +extern GrB_BinaryOp GxB_LAND_BOOL; +extern GrB_BinaryOp GxB_LAND_FP32; +extern GrB_BinaryOp GxB_LAND_FP64; +extern GrB_BinaryOp GxB_LAND_INT8; +extern GrB_BinaryOp GxB_LAND_INT16; +extern GrB_BinaryOp GxB_LAND_INT32; +extern GrB_BinaryOp GxB_LAND_INT64; +extern GrB_BinaryOp GxB_LAND_UINT8; +extern GrB_BinaryOp GxB_LAND_UINT16; +extern GrB_BinaryOp GxB_LAND_UINT32; +extern GrB_BinaryOp GxB_LAND_UINT64; +extern GrB_BinaryOp GxB_LDEXP_FP32; +extern GrB_BinaryOp GxB_LDEXP_FP64; +extern GrB_BinaryOp GxB_LOR_BOOL; +extern GrB_BinaryOp GxB_LOR_FP32; +extern GrB_BinaryOp GxB_LOR_FP64; +extern GrB_BinaryOp GxB_LOR_INT8; +extern GrB_BinaryOp GxB_LOR_INT16; +extern GrB_BinaryOp GxB_LOR_INT32; +extern GrB_BinaryOp GxB_LOR_INT64; +extern GrB_BinaryOp GxB_LOR_UINT8; +extern GrB_BinaryOp GxB_LOR_UINT16; +extern GrB_BinaryOp GxB_LOR_UINT32; +extern GrB_BinaryOp GxB_LOR_UINT64; +extern GrB_BinaryOp GxB_LXOR_BOOL; +extern GrB_BinaryOp GxB_LXOR_FP32; +extern GrB_BinaryOp GxB_LXOR_FP64; +extern GrB_BinaryOp GxB_LXOR_INT8; +extern GrB_BinaryOp GxB_LXOR_INT16; +extern GrB_BinaryOp GxB_LXOR_INT32; +extern GrB_BinaryOp GxB_LXOR_INT64; +extern GrB_BinaryOp GxB_LXOR_UINT8; +extern GrB_BinaryOp GxB_LXOR_UINT16; +extern GrB_BinaryOp GxB_LXOR_UINT32; +extern GrB_BinaryOp GxB_LXOR_UINT64; +extern GrB_BinaryOp GxB_PAIR_BOOL; +extern GrB_BinaryOp GxB_PAIR_FP32; +extern GrB_BinaryOp GxB_PAIR_FP64; +extern GrB_BinaryOp GxB_PAIR_INT8; +extern GrB_BinaryOp GxB_PAIR_INT16; +extern GrB_BinaryOp GxB_PAIR_INT32; +extern GrB_BinaryOp GxB_PAIR_INT64; +extern GrB_BinaryOp GxB_PAIR_UINT8; +extern GrB_BinaryOp GxB_PAIR_UINT16; +extern GrB_BinaryOp GxB_PAIR_UINT32; +extern GrB_BinaryOp GxB_PAIR_UINT64; +extern GrB_BinaryOp GxB_POW_BOOL; +extern GrB_BinaryOp GxB_POW_FP32; +extern GrB_BinaryOp GxB_POW_FP64; +extern GrB_BinaryOp GxB_POW_INT8; +extern GrB_BinaryOp GxB_POW_INT16; +extern GrB_BinaryOp GxB_POW_INT32; +extern GrB_BinaryOp GxB_POW_INT64; +extern GrB_BinaryOp GxB_POW_UINT8; +extern GrB_BinaryOp GxB_POW_UINT16; +extern GrB_BinaryOp GxB_POW_UINT32; +extern GrB_BinaryOp GxB_POW_UINT64; +extern GrB_BinaryOp GxB_RDIV_BOOL; +extern GrB_BinaryOp GxB_RDIV_FP32; +extern GrB_BinaryOp GxB_RDIV_FP64; +extern GrB_BinaryOp GxB_RDIV_INT8; +extern GrB_BinaryOp GxB_RDIV_INT16; +extern GrB_BinaryOp GxB_RDIV_INT32; +extern GrB_BinaryOp GxB_RDIV_INT64; +extern GrB_BinaryOp GxB_RDIV_UINT8; +extern GrB_BinaryOp GxB_RDIV_UINT16; +extern GrB_BinaryOp GxB_RDIV_UINT32; +extern GrB_BinaryOp GxB_RDIV_UINT64; +extern GrB_BinaryOp GxB_REMAINDER_FP32; +extern GrB_BinaryOp GxB_REMAINDER_FP64; +extern GrB_BinaryOp GxB_RMINUS_BOOL; +extern GrB_BinaryOp GxB_RMINUS_FP32; +extern GrB_BinaryOp GxB_RMINUS_FP64; +extern GrB_BinaryOp GxB_RMINUS_INT8; +extern GrB_BinaryOp GxB_RMINUS_INT16; +extern GrB_BinaryOp GxB_RMINUS_INT32; +extern GrB_BinaryOp GxB_RMINUS_INT64; +extern GrB_BinaryOp GxB_RMINUS_UINT8; +extern GrB_BinaryOp GxB_RMINUS_UINT16; +extern GrB_BinaryOp GxB_RMINUS_UINT32; +extern GrB_BinaryOp GxB_RMINUS_UINT64; +extern GrB_BinaryOp GxB_SECONDI1_INT32; +extern GrB_BinaryOp GxB_SECONDI1_INT64; +extern GrB_BinaryOp GxB_SECONDI_INT32; +extern GrB_BinaryOp GxB_SECONDI_INT64; +extern GrB_BinaryOp GxB_SECONDJ1_INT32; +extern GrB_BinaryOp GxB_SECONDJ1_INT64; +extern GrB_BinaryOp GxB_SECONDJ_INT32; +extern GrB_BinaryOp GxB_SECONDJ_INT64; +extern GrB_Monoid GxB_ANY_BOOL_MONOID; +extern GrB_Monoid GxB_ANY_FP32_MONOID; +extern GrB_Monoid GxB_ANY_FP64_MONOID; +extern GrB_Monoid GxB_ANY_INT8_MONOID; +extern GrB_Monoid GxB_ANY_INT16_MONOID; +extern GrB_Monoid GxB_ANY_INT32_MONOID; +extern GrB_Monoid GxB_ANY_INT64_MONOID; +extern GrB_Monoid GxB_ANY_UINT8_MONOID; +extern GrB_Monoid GxB_ANY_UINT16_MONOID; +extern GrB_Monoid GxB_ANY_UINT32_MONOID; +extern GrB_Monoid GxB_ANY_UINT64_MONOID; +extern GrB_Monoid GxB_BAND_UINT8_MONOID; +extern GrB_Monoid GxB_BAND_UINT16_MONOID; +extern GrB_Monoid GxB_BAND_UINT32_MONOID; +extern GrB_Monoid GxB_BAND_UINT64_MONOID; +extern GrB_Monoid GxB_BOR_UINT8_MONOID; +extern GrB_Monoid GxB_BOR_UINT16_MONOID; +extern GrB_Monoid GxB_BOR_UINT32_MONOID; +extern GrB_Monoid GxB_BOR_UINT64_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT8_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT16_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT32_MONOID; +extern GrB_Monoid GxB_BXNOR_UINT64_MONOID; +extern GrB_Monoid GxB_BXOR_UINT8_MONOID; +extern GrB_Monoid GxB_BXOR_UINT16_MONOID; +extern GrB_Monoid GxB_BXOR_UINT32_MONOID; +extern GrB_Monoid GxB_BXOR_UINT64_MONOID; +extern GrB_Monoid GxB_EQ_BOOL_MONOID; +extern GrB_Semiring GxB_ANY_DIV_FP32; +extern GrB_Semiring GxB_ANY_DIV_FP64; +extern GrB_Semiring GxB_ANY_DIV_INT8; +extern GrB_Semiring GxB_ANY_DIV_INT16; +extern GrB_Semiring GxB_ANY_DIV_INT32; +extern GrB_Semiring GxB_ANY_DIV_INT64; +extern GrB_Semiring GxB_ANY_DIV_UINT8; +extern GrB_Semiring GxB_ANY_DIV_UINT16; +extern GrB_Semiring GxB_ANY_DIV_UINT32; +extern GrB_Semiring GxB_ANY_DIV_UINT64; +extern GrB_Semiring GxB_ANY_EQ_BOOL; +extern GrB_Semiring GxB_ANY_EQ_FP32; +extern GrB_Semiring GxB_ANY_EQ_FP64; +extern GrB_Semiring GxB_ANY_EQ_INT8; +extern GrB_Semiring GxB_ANY_EQ_INT16; +extern GrB_Semiring GxB_ANY_EQ_INT32; +extern GrB_Semiring GxB_ANY_EQ_INT64; +extern GrB_Semiring GxB_ANY_EQ_UINT8; +extern GrB_Semiring GxB_ANY_EQ_UINT16; +extern GrB_Semiring GxB_ANY_EQ_UINT32; +extern GrB_Semiring GxB_ANY_EQ_UINT64; +extern GrB_Semiring GxB_ANY_FIRSTI1_INT32; +extern GrB_Semiring GxB_ANY_FIRSTI1_INT64; +extern GrB_Semiring GxB_ANY_FIRSTI_INT32; +extern GrB_Semiring GxB_ANY_FIRSTI_INT64; +extern GrB_Semiring GxB_ANY_FIRSTJ1_INT32; +extern GrB_Semiring GxB_ANY_FIRSTJ1_INT64; +extern GrB_Semiring GxB_ANY_FIRSTJ_INT32; +extern GrB_Semiring GxB_ANY_FIRSTJ_INT64; +extern GrB_Semiring GxB_ANY_FIRST_BOOL; +extern GrB_Semiring GxB_ANY_FIRST_FP32; +extern GrB_Semiring GxB_ANY_FIRST_FP64; +extern GrB_Semiring GxB_ANY_FIRST_INT8; +extern GrB_Semiring GxB_ANY_FIRST_INT16; +extern GrB_Semiring GxB_ANY_FIRST_INT32; +extern GrB_Semiring GxB_ANY_FIRST_INT64; +extern GrB_Semiring GxB_ANY_FIRST_UINT8; +extern GrB_Semiring GxB_ANY_FIRST_UINT16; +extern GrB_Semiring GxB_ANY_FIRST_UINT32; +extern GrB_Semiring GxB_ANY_FIRST_UINT64; +extern GrB_Semiring GxB_ANY_GE_BOOL; +extern GrB_Semiring GxB_ANY_GE_FP32; +extern GrB_Semiring GxB_ANY_GE_FP64; +extern GrB_Semiring GxB_ANY_GE_INT8; +extern GrB_Semiring GxB_ANY_GE_INT16; +extern GrB_Semiring GxB_ANY_GE_INT32; +extern GrB_Semiring GxB_ANY_GE_INT64; +extern GrB_Semiring GxB_ANY_GE_UINT8; +extern GrB_Semiring GxB_ANY_GE_UINT16; +extern GrB_Semiring GxB_ANY_GE_UINT32; +extern GrB_Semiring GxB_ANY_GE_UINT64; +extern GrB_Semiring GxB_ANY_GT_BOOL; +extern GrB_Semiring GxB_ANY_GT_FP32; +extern GrB_Semiring GxB_ANY_GT_FP64; +extern GrB_Semiring GxB_ANY_GT_INT8; +extern GrB_Semiring GxB_ANY_GT_INT16; +extern GrB_Semiring GxB_ANY_GT_INT32; +extern GrB_Semiring GxB_ANY_GT_INT64; +extern GrB_Semiring GxB_ANY_GT_UINT8; +extern GrB_Semiring GxB_ANY_GT_UINT16; +extern GrB_Semiring GxB_ANY_GT_UINT32; +extern GrB_Semiring GxB_ANY_GT_UINT64; +extern GrB_Semiring GxB_ANY_ISEQ_FP32; +extern GrB_Semiring GxB_ANY_ISEQ_FP64; +extern GrB_Semiring GxB_ANY_ISEQ_INT8; +extern GrB_Semiring GxB_ANY_ISEQ_INT16; +extern GrB_Semiring GxB_ANY_ISEQ_INT32; +extern GrB_Semiring GxB_ANY_ISEQ_INT64; +extern GrB_Semiring GxB_ANY_ISEQ_UINT8; +extern GrB_Semiring GxB_ANY_ISEQ_UINT16; +extern GrB_Semiring GxB_ANY_ISEQ_UINT32; +extern GrB_Semiring GxB_ANY_ISEQ_UINT64; +extern GrB_Semiring GxB_ANY_ISGE_FP32; +extern GrB_Semiring GxB_ANY_ISGE_FP64; +extern GrB_Semiring GxB_ANY_ISGE_INT8; +extern GrB_Semiring GxB_ANY_ISGE_INT16; +extern GrB_Semiring GxB_ANY_ISGE_INT32; +extern GrB_Semiring GxB_ANY_ISGE_INT64; +extern GrB_Semiring GxB_ANY_ISGE_UINT8; +extern GrB_Semiring GxB_ANY_ISGE_UINT16; +extern GrB_Semiring GxB_ANY_ISGE_UINT32; +extern GrB_Semiring GxB_ANY_ISGE_UINT64; +extern GrB_Semiring GxB_ANY_ISGT_FP32; +extern GrB_Semiring GxB_ANY_ISGT_FP64; +extern GrB_Semiring GxB_ANY_ISGT_INT8; +extern GrB_Semiring GxB_ANY_ISGT_INT16; +extern GrB_Semiring GxB_ANY_ISGT_INT32; +extern GrB_Semiring GxB_ANY_ISGT_INT64; +extern GrB_Semiring GxB_ANY_ISGT_UINT8; +extern GrB_Semiring GxB_ANY_ISGT_UINT16; +extern GrB_Semiring GxB_ANY_ISGT_UINT32; +extern GrB_Semiring GxB_ANY_ISGT_UINT64; +extern GrB_Semiring GxB_ANY_ISLE_FP32; +extern GrB_Semiring GxB_ANY_ISLE_FP64; +extern GrB_Semiring GxB_ANY_ISLE_INT8; +extern GrB_Semiring GxB_ANY_ISLE_INT16; +extern GrB_Semiring GxB_ANY_ISLE_INT32; +extern GrB_Semiring GxB_ANY_ISLE_INT64; +extern GrB_Semiring GxB_ANY_ISLE_UINT8; +extern GrB_Semiring GxB_ANY_ISLE_UINT16; +extern GrB_Semiring GxB_ANY_ISLE_UINT32; +extern GrB_Semiring GxB_ANY_ISLE_UINT64; +extern GrB_Semiring GxB_ANY_ISLT_FP32; +extern GrB_Semiring GxB_ANY_ISLT_FP64; +extern GrB_Semiring GxB_ANY_ISLT_INT8; +extern GrB_Semiring GxB_ANY_ISLT_INT16; +extern GrB_Semiring GxB_ANY_ISLT_INT32; +extern GrB_Semiring GxB_ANY_ISLT_INT64; +extern GrB_Semiring GxB_ANY_ISLT_UINT8; +extern GrB_Semiring GxB_ANY_ISLT_UINT16; +extern GrB_Semiring GxB_ANY_ISLT_UINT32; +extern GrB_Semiring GxB_ANY_ISLT_UINT64; +extern GrB_Semiring GxB_ANY_ISNE_FP32; +extern GrB_Semiring GxB_ANY_ISNE_FP64; +extern GrB_Semiring GxB_ANY_ISNE_INT8; +extern GrB_Semiring GxB_ANY_ISNE_INT16; +extern GrB_Semiring GxB_ANY_ISNE_INT32; +extern GrB_Semiring GxB_ANY_ISNE_INT64; +extern GrB_Semiring GxB_ANY_ISNE_UINT8; +extern GrB_Semiring GxB_ANY_ISNE_UINT16; +extern GrB_Semiring GxB_ANY_ISNE_UINT32; +extern GrB_Semiring GxB_ANY_ISNE_UINT64; +extern GrB_Semiring GxB_ANY_LAND_BOOL; +extern GrB_Semiring GxB_ANY_LAND_FP32; +extern GrB_Semiring GxB_ANY_LAND_FP64; +extern GrB_Semiring GxB_ANY_LAND_INT8; +extern GrB_Semiring GxB_ANY_LAND_INT16; +extern GrB_Semiring GxB_ANY_LAND_INT32; +extern GrB_Semiring GxB_ANY_LAND_INT64; +extern GrB_Semiring GxB_ANY_LAND_UINT8; +extern GrB_Semiring GxB_ANY_LAND_UINT16; +extern GrB_Semiring GxB_ANY_LAND_UINT32; +extern GrB_Semiring GxB_ANY_LAND_UINT64; +extern GrB_Semiring GxB_ANY_LE_BOOL; +extern GrB_Semiring GxB_ANY_LE_FP32; +extern GrB_Semiring GxB_ANY_LE_FP64; +extern GrB_Semiring GxB_ANY_LE_INT8; +extern GrB_Semiring GxB_ANY_LE_INT16; +extern GrB_Semiring GxB_ANY_LE_INT32; +extern GrB_Semiring GxB_ANY_LE_INT64; +extern GrB_Semiring GxB_ANY_LE_UINT8; +extern GrB_Semiring GxB_ANY_LE_UINT16; +extern GrB_Semiring GxB_ANY_LE_UINT32; +extern GrB_Semiring GxB_ANY_LE_UINT64; +extern GrB_Semiring GxB_ANY_LOR_BOOL; +extern GrB_Semiring GxB_ANY_LOR_FP32; +extern GrB_Semiring GxB_ANY_LOR_FP64; +extern GrB_Semiring GxB_ANY_LOR_INT8; +extern GrB_Semiring GxB_ANY_LOR_INT16; +extern GrB_Semiring GxB_ANY_LOR_INT32; +extern GrB_Semiring GxB_ANY_LOR_INT64; +extern GrB_Semiring GxB_ANY_LOR_UINT8; +extern GrB_Semiring GxB_ANY_LOR_UINT16; +extern GrB_Semiring GxB_ANY_LOR_UINT32; +extern GrB_Semiring GxB_ANY_LOR_UINT64; +extern GrB_Semiring GxB_ANY_LT_BOOL; +extern GrB_Semiring GxB_ANY_LT_FP32; +extern GrB_Semiring GxB_ANY_LT_FP64; +extern GrB_Semiring GxB_ANY_LT_INT8; +extern GrB_Semiring GxB_ANY_LT_INT16; +extern GrB_Semiring GxB_ANY_LT_INT32; +extern GrB_Semiring GxB_ANY_LT_INT64; +extern GrB_Semiring GxB_ANY_LT_UINT8; +extern GrB_Semiring GxB_ANY_LT_UINT16; +extern GrB_Semiring GxB_ANY_LT_UINT32; +extern GrB_Semiring GxB_ANY_LT_UINT64; +extern GrB_Semiring GxB_ANY_LXOR_BOOL; +extern GrB_Semiring GxB_ANY_LXOR_FP32; +extern GrB_Semiring GxB_ANY_LXOR_FP64; +extern GrB_Semiring GxB_ANY_LXOR_INT8; +extern GrB_Semiring GxB_ANY_LXOR_INT16; +extern GrB_Semiring GxB_ANY_LXOR_INT32; +extern GrB_Semiring GxB_ANY_LXOR_INT64; +extern GrB_Semiring GxB_ANY_LXOR_UINT8; +extern GrB_Semiring GxB_ANY_LXOR_UINT16; +extern GrB_Semiring GxB_ANY_LXOR_UINT32; +extern GrB_Semiring GxB_ANY_LXOR_UINT64; +extern GrB_Semiring GxB_ANY_MAX_FP32; +extern GrB_Semiring GxB_ANY_MAX_FP64; +extern GrB_Semiring GxB_ANY_MAX_INT8; +extern GrB_Semiring GxB_ANY_MAX_INT16; +extern GrB_Semiring GxB_ANY_MAX_INT32; +extern GrB_Semiring GxB_ANY_MAX_INT64; +extern GrB_Semiring GxB_ANY_MAX_UINT8; +extern GrB_Semiring GxB_ANY_MAX_UINT16; +extern GrB_Semiring GxB_ANY_MAX_UINT32; +extern GrB_Semiring GxB_ANY_MAX_UINT64; +extern GrB_Semiring GxB_ANY_MINUS_FP32; +extern GrB_Semiring GxB_ANY_MINUS_FP64; +extern GrB_Semiring GxB_ANY_MINUS_INT8; +extern GrB_Semiring GxB_ANY_MINUS_INT16; +extern GrB_Semiring GxB_ANY_MINUS_INT32; +extern GrB_Semiring GxB_ANY_MINUS_INT64; +extern GrB_Semiring GxB_ANY_MINUS_UINT8; +extern GrB_Semiring GxB_ANY_MINUS_UINT16; +extern GrB_Semiring GxB_ANY_MINUS_UINT32; +extern GrB_Semiring GxB_ANY_MINUS_UINT64; +extern GrB_Semiring GxB_ANY_MIN_FP32; +extern GrB_Semiring GxB_ANY_MIN_FP64; +extern GrB_Semiring GxB_ANY_MIN_INT8; +extern GrB_Semiring GxB_ANY_MIN_INT16; +extern GrB_Semiring GxB_ANY_MIN_INT32; +extern GrB_Semiring GxB_ANY_MIN_INT64; +extern GrB_Semiring GxB_ANY_MIN_UINT8; +extern GrB_Semiring GxB_ANY_MIN_UINT16; +extern GrB_Semiring GxB_ANY_MIN_UINT32; +extern GrB_Semiring GxB_ANY_MIN_UINT64; +extern GrB_Semiring GxB_ANY_NE_FP32; +extern GrB_Semiring GxB_ANY_NE_FP64; +extern GrB_Semiring GxB_ANY_NE_INT8; +extern GrB_Semiring GxB_ANY_NE_INT16; +extern GrB_Semiring GxB_ANY_NE_INT32; +extern GrB_Semiring GxB_ANY_NE_INT64; +extern GrB_Semiring GxB_ANY_NE_UINT8; +extern GrB_Semiring GxB_ANY_NE_UINT16; +extern GrB_Semiring GxB_ANY_NE_UINT32; +extern GrB_Semiring GxB_ANY_NE_UINT64; +extern GrB_Semiring GxB_ANY_PAIR_BOOL; +extern GrB_Semiring GxB_ANY_PAIR_FP32; +extern GrB_Semiring GxB_ANY_PAIR_FP64; +extern GrB_Semiring GxB_ANY_PAIR_INT8; +extern GrB_Semiring GxB_ANY_PAIR_INT16; +extern GrB_Semiring GxB_ANY_PAIR_INT32; +extern GrB_Semiring GxB_ANY_PAIR_INT64; +extern GrB_Semiring GxB_ANY_PAIR_UINT8; +extern GrB_Semiring GxB_ANY_PAIR_UINT16; +extern GrB_Semiring GxB_ANY_PAIR_UINT32; +extern GrB_Semiring GxB_ANY_PAIR_UINT64; +extern GrB_Semiring GxB_ANY_PLUS_FP32; +extern GrB_Semiring GxB_ANY_PLUS_FP64; +extern GrB_Semiring GxB_ANY_PLUS_INT8; +extern GrB_Semiring GxB_ANY_PLUS_INT16; +extern GrB_Semiring GxB_ANY_PLUS_INT32; +extern GrB_Semiring GxB_ANY_PLUS_INT64; +extern GrB_Semiring GxB_ANY_PLUS_UINT8; +extern GrB_Semiring GxB_ANY_PLUS_UINT16; +extern GrB_Semiring GxB_ANY_PLUS_UINT32; +extern GrB_Semiring GxB_ANY_PLUS_UINT64; +extern GrB_Semiring GxB_ANY_RDIV_FP32; +extern GrB_Semiring GxB_ANY_RDIV_FP64; +extern GrB_Semiring GxB_ANY_RDIV_INT8; +extern GrB_Semiring GxB_ANY_RDIV_INT16; +extern GrB_Semiring GxB_ANY_RDIV_INT32; +extern GrB_Semiring GxB_ANY_RDIV_INT64; +extern GrB_Semiring GxB_ANY_RDIV_UINT8; +extern GrB_Semiring GxB_ANY_RDIV_UINT16; +extern GrB_Semiring GxB_ANY_RDIV_UINT32; +extern GrB_Semiring GxB_ANY_RDIV_UINT64; +extern GrB_Semiring GxB_ANY_RMINUS_FP32; +extern GrB_Semiring GxB_ANY_RMINUS_FP64; +extern GrB_Semiring GxB_ANY_RMINUS_INT8; +extern GrB_Semiring GxB_ANY_RMINUS_INT16; +extern GrB_Semiring GxB_ANY_RMINUS_INT32; +extern GrB_Semiring GxB_ANY_RMINUS_INT64; +extern GrB_Semiring GxB_ANY_RMINUS_UINT8; +extern GrB_Semiring GxB_ANY_RMINUS_UINT16; +extern GrB_Semiring GxB_ANY_RMINUS_UINT32; +extern GrB_Semiring GxB_ANY_RMINUS_UINT64; +extern GrB_Semiring GxB_ANY_SECONDI1_INT32; +extern GrB_Semiring GxB_ANY_SECONDI1_INT64; +extern GrB_Semiring GxB_ANY_SECONDI_INT32; +extern GrB_Semiring GxB_ANY_SECONDI_INT64; +extern GrB_Semiring GxB_ANY_SECONDJ1_INT32; +extern GrB_Semiring GxB_ANY_SECONDJ1_INT64; +extern GrB_Semiring GxB_ANY_SECONDJ_INT32; +extern GrB_Semiring GxB_ANY_SECONDJ_INT64; +extern GrB_Semiring GxB_ANY_SECOND_BOOL; +extern GrB_Semiring GxB_ANY_SECOND_FP32; +extern GrB_Semiring GxB_ANY_SECOND_FP64; +extern GrB_Semiring GxB_ANY_SECOND_INT8; +extern GrB_Semiring GxB_ANY_SECOND_INT16; +extern GrB_Semiring GxB_ANY_SECOND_INT32; +extern GrB_Semiring GxB_ANY_SECOND_INT64; +extern GrB_Semiring GxB_ANY_SECOND_UINT8; +extern GrB_Semiring GxB_ANY_SECOND_UINT16; +extern GrB_Semiring GxB_ANY_SECOND_UINT32; +extern GrB_Semiring GxB_ANY_SECOND_UINT64; +extern GrB_Semiring GxB_ANY_TIMES_FP32; +extern GrB_Semiring GxB_ANY_TIMES_FP64; +extern GrB_Semiring GxB_ANY_TIMES_INT8; +extern GrB_Semiring GxB_ANY_TIMES_INT16; +extern GrB_Semiring GxB_ANY_TIMES_INT32; +extern GrB_Semiring GxB_ANY_TIMES_INT64; +extern GrB_Semiring GxB_ANY_TIMES_UINT8; +extern GrB_Semiring GxB_ANY_TIMES_UINT16; +extern GrB_Semiring GxB_ANY_TIMES_UINT32; +extern GrB_Semiring GxB_ANY_TIMES_UINT64; +extern GrB_Semiring GxB_BAND_BAND_UINT8; +extern GrB_Semiring GxB_BAND_BAND_UINT16; +extern GrB_Semiring GxB_BAND_BAND_UINT32; +extern GrB_Semiring GxB_BAND_BAND_UINT64; +extern GrB_Semiring GxB_BAND_BOR_UINT8; +extern GrB_Semiring GxB_BAND_BOR_UINT16; +extern GrB_Semiring GxB_BAND_BOR_UINT32; +extern GrB_Semiring GxB_BAND_BOR_UINT64; +extern GrB_Semiring GxB_BAND_BXNOR_UINT8; +extern GrB_Semiring GxB_BAND_BXNOR_UINT16; +extern GrB_Semiring GxB_BAND_BXNOR_UINT32; +extern GrB_Semiring GxB_BAND_BXNOR_UINT64; +extern GrB_Semiring GxB_BAND_BXOR_UINT8; +extern GrB_Semiring GxB_BAND_BXOR_UINT16; +extern GrB_Semiring GxB_BAND_BXOR_UINT32; +extern GrB_Semiring GxB_BAND_BXOR_UINT64; +extern GrB_Semiring GxB_BOR_BAND_UINT8; +extern GrB_Semiring GxB_BOR_BAND_UINT16; +extern GrB_Semiring GxB_BOR_BAND_UINT32; +extern GrB_Semiring GxB_BOR_BAND_UINT64; +extern GrB_Semiring GxB_BOR_BOR_UINT8; +extern GrB_Semiring GxB_BOR_BOR_UINT16; +extern GrB_Semiring GxB_BOR_BOR_UINT32; +extern GrB_Semiring GxB_BOR_BOR_UINT64; +extern GrB_Semiring GxB_BOR_BXNOR_UINT8; +extern GrB_Semiring GxB_BOR_BXNOR_UINT16; +extern GrB_Semiring GxB_BOR_BXNOR_UINT32; +extern GrB_Semiring GxB_BOR_BXNOR_UINT64; +extern GrB_Semiring GxB_BOR_BXOR_UINT8; +extern GrB_Semiring GxB_BOR_BXOR_UINT16; +extern GrB_Semiring GxB_BOR_BXOR_UINT32; +extern GrB_Semiring GxB_BOR_BXOR_UINT64; +extern GrB_Semiring GxB_BXNOR_BAND_UINT8; +extern GrB_Semiring GxB_BXNOR_BAND_UINT16; +extern GrB_Semiring GxB_BXNOR_BAND_UINT32; +extern GrB_Semiring GxB_BXNOR_BAND_UINT64; +extern GrB_Semiring GxB_BXNOR_BOR_UINT8; +extern GrB_Semiring GxB_BXNOR_BOR_UINT16; +extern GrB_Semiring GxB_BXNOR_BOR_UINT32; +extern GrB_Semiring GxB_BXNOR_BOR_UINT64; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT8; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT16; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT32; +extern GrB_Semiring GxB_BXNOR_BXNOR_UINT64; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT8; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT16; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT32; +extern GrB_Semiring GxB_BXNOR_BXOR_UINT64; +extern GrB_Semiring GxB_BXOR_BAND_UINT8; +extern GrB_Semiring GxB_BXOR_BAND_UINT16; +extern GrB_Semiring GxB_BXOR_BAND_UINT32; +extern GrB_Semiring GxB_BXOR_BAND_UINT64; +extern GrB_Semiring GxB_BXOR_BOR_UINT8; +extern GrB_Semiring GxB_BXOR_BOR_UINT16; +extern GrB_Semiring GxB_BXOR_BOR_UINT32; +extern GrB_Semiring GxB_BXOR_BOR_UINT64; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT8; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT16; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT32; +extern GrB_Semiring GxB_BXOR_BXNOR_UINT64; +extern GrB_Semiring GxB_BXOR_BXOR_UINT8; +extern GrB_Semiring GxB_BXOR_BXOR_UINT16; +extern GrB_Semiring GxB_BXOR_BXOR_UINT32; +extern GrB_Semiring GxB_BXOR_BXOR_UINT64; +extern GrB_Semiring GxB_EQ_EQ_BOOL; +extern GrB_Semiring GxB_EQ_EQ_FP32; +extern GrB_Semiring GxB_EQ_EQ_FP64; +extern GrB_Semiring GxB_EQ_EQ_INT8; +extern GrB_Semiring GxB_EQ_EQ_INT16; +extern GrB_Semiring GxB_EQ_EQ_INT32; +extern GrB_Semiring GxB_EQ_EQ_INT64; +extern GrB_Semiring GxB_EQ_EQ_UINT8; +extern GrB_Semiring GxB_EQ_EQ_UINT16; +extern GrB_Semiring GxB_EQ_EQ_UINT32; +extern GrB_Semiring GxB_EQ_EQ_UINT64; +extern GrB_Semiring GxB_EQ_FIRST_BOOL; +extern GrB_Semiring GxB_EQ_GE_BOOL; +extern GrB_Semiring GxB_EQ_GE_FP32; +extern GrB_Semiring GxB_EQ_GE_FP64; +extern GrB_Semiring GxB_EQ_GE_INT8; +extern GrB_Semiring GxB_EQ_GE_INT16; +extern GrB_Semiring GxB_EQ_GE_INT32; +extern GrB_Semiring GxB_EQ_GE_INT64; +extern GrB_Semiring GxB_EQ_GE_UINT8; +extern GrB_Semiring GxB_EQ_GE_UINT16; +extern GrB_Semiring GxB_EQ_GE_UINT32; +extern GrB_Semiring GxB_EQ_GE_UINT64; +extern GrB_Semiring GxB_EQ_GT_BOOL; +extern GrB_Semiring GxB_EQ_GT_FP32; +extern GrB_Semiring GxB_EQ_GT_FP64; +extern GrB_Semiring GxB_EQ_GT_INT8; +extern GrB_Semiring GxB_EQ_GT_INT16; +extern GrB_Semiring GxB_EQ_GT_INT32; +extern GrB_Semiring GxB_EQ_GT_INT64; +extern GrB_Semiring GxB_EQ_GT_UINT8; +extern GrB_Semiring GxB_EQ_GT_UINT16; +extern GrB_Semiring GxB_EQ_GT_UINT32; +extern GrB_Semiring GxB_EQ_GT_UINT64; +extern GrB_Semiring GxB_EQ_LAND_BOOL; +extern GrB_Semiring GxB_EQ_LE_BOOL; +extern GrB_Semiring GxB_EQ_LE_FP32; +extern GrB_Semiring GxB_EQ_LE_FP64; +extern GrB_Semiring GxB_EQ_LE_INT8; +extern GrB_Semiring GxB_EQ_LE_INT16; +extern GrB_Semiring GxB_EQ_LE_INT32; +extern GrB_Semiring GxB_EQ_LE_INT64; +extern GrB_Semiring GxB_EQ_LE_UINT8; +extern GrB_Semiring GxB_EQ_LE_UINT16; +extern GrB_Semiring GxB_EQ_LE_UINT32; +extern GrB_Semiring GxB_EQ_LE_UINT64; +extern GrB_Semiring GxB_EQ_LOR_BOOL; +extern GrB_Semiring GxB_EQ_LT_BOOL; +extern GrB_Semiring GxB_EQ_LT_FP32; +extern GrB_Semiring GxB_EQ_LT_FP64; +extern GrB_Semiring GxB_EQ_LT_INT8; +extern GrB_Semiring GxB_EQ_LT_INT16; +extern GrB_Semiring GxB_EQ_LT_INT32; +extern GrB_Semiring GxB_EQ_LT_INT64; +extern GrB_Semiring GxB_EQ_LT_UINT8; +extern GrB_Semiring GxB_EQ_LT_UINT16; +extern GrB_Semiring GxB_EQ_LT_UINT32; +extern GrB_Semiring GxB_EQ_LT_UINT64; +extern GrB_Semiring GxB_EQ_LXOR_BOOL; +extern GrB_Semiring GxB_EQ_NE_FP32; +extern GrB_Semiring GxB_EQ_NE_FP64; +extern GrB_Semiring GxB_EQ_NE_INT8; +extern GrB_Semiring GxB_EQ_NE_INT16; +extern GrB_Semiring GxB_EQ_NE_INT32; +extern GrB_Semiring GxB_EQ_NE_INT64; +extern GrB_Semiring GxB_EQ_NE_UINT8; +extern GrB_Semiring GxB_EQ_NE_UINT16; +extern GrB_Semiring GxB_EQ_NE_UINT32; +extern GrB_Semiring GxB_EQ_NE_UINT64; +extern GrB_Semiring GxB_EQ_PAIR_BOOL; +extern GrB_Semiring GxB_EQ_SECOND_BOOL; +extern GrB_Semiring GxB_LAND_EQ_BOOL; +extern GrB_Semiring GxB_LAND_EQ_FP32; +extern GrB_Semiring GxB_LAND_EQ_FP64; +extern GrB_Semiring GxB_LAND_EQ_INT8; +extern GrB_Semiring GxB_LAND_EQ_INT16; +extern GrB_Semiring GxB_LAND_EQ_INT32; +extern GrB_Semiring GxB_LAND_EQ_INT64; +extern GrB_Semiring GxB_LAND_EQ_UINT8; +extern GrB_Semiring GxB_LAND_EQ_UINT16; +extern GrB_Semiring GxB_LAND_EQ_UINT32; +extern GrB_Semiring GxB_LAND_EQ_UINT64; +extern GrB_Semiring GxB_LAND_FIRST_BOOL; +extern GrB_Semiring GxB_LAND_GE_BOOL; +extern GrB_Semiring GxB_LAND_GE_FP32; +extern GrB_Semiring GxB_LAND_GE_FP64; +extern GrB_Semiring GxB_LAND_GE_INT8; +extern GrB_Semiring GxB_LAND_GE_INT16; +extern GrB_Semiring GxB_LAND_GE_INT32; +extern GrB_Semiring GxB_LAND_GE_INT64; +extern GrB_Semiring GxB_LAND_GE_UINT8; +extern GrB_Semiring GxB_LAND_GE_UINT16; +extern GrB_Semiring GxB_LAND_GE_UINT32; +extern GrB_Semiring GxB_LAND_GE_UINT64; +extern GrB_Semiring GxB_LAND_GT_BOOL; +extern GrB_Semiring GxB_LAND_GT_FP32; +extern GrB_Semiring GxB_LAND_GT_FP64; +extern GrB_Semiring GxB_LAND_GT_INT8; +extern GrB_Semiring GxB_LAND_GT_INT16; +extern GrB_Semiring GxB_LAND_GT_INT32; +extern GrB_Semiring GxB_LAND_GT_INT64; +extern GrB_Semiring GxB_LAND_GT_UINT8; +extern GrB_Semiring GxB_LAND_GT_UINT16; +extern GrB_Semiring GxB_LAND_GT_UINT32; +extern GrB_Semiring GxB_LAND_GT_UINT64; +extern GrB_Semiring GxB_LAND_LAND_BOOL; +extern GrB_Semiring GxB_LAND_LE_BOOL; +extern GrB_Semiring GxB_LAND_LE_FP32; +extern GrB_Semiring GxB_LAND_LE_FP64; +extern GrB_Semiring GxB_LAND_LE_INT8; +extern GrB_Semiring GxB_LAND_LE_INT16; +extern GrB_Semiring GxB_LAND_LE_INT32; +extern GrB_Semiring GxB_LAND_LE_INT64; +extern GrB_Semiring GxB_LAND_LE_UINT8; +extern GrB_Semiring GxB_LAND_LE_UINT16; +extern GrB_Semiring GxB_LAND_LE_UINT32; +extern GrB_Semiring GxB_LAND_LE_UINT64; +extern GrB_Semiring GxB_LAND_LT_BOOL; +extern GrB_Semiring GxB_LAND_LT_FP32; +extern GrB_Semiring GxB_LAND_LT_FP64; +extern GrB_Semiring GxB_LAND_LT_INT8; +extern GrB_Semiring GxB_LAND_LT_INT16; +extern GrB_Semiring GxB_LAND_LT_INT32; +extern GrB_Semiring GxB_LAND_LT_INT64; +extern GrB_Semiring GxB_LAND_LT_UINT8; +extern GrB_Semiring GxB_LAND_LT_UINT16; +extern GrB_Semiring GxB_LAND_LT_UINT32; +extern GrB_Semiring GxB_LAND_LT_UINT64; +extern GrB_Semiring GxB_LAND_LXOR_BOOL; +extern GrB_Semiring GxB_LAND_NE_FP32; +extern GrB_Semiring GxB_LAND_NE_FP64; +extern GrB_Semiring GxB_LAND_NE_INT8; +extern GrB_Semiring GxB_LAND_NE_INT16; +extern GrB_Semiring GxB_LAND_NE_INT32; +extern GrB_Semiring GxB_LAND_NE_INT64; +extern GrB_Semiring GxB_LAND_NE_UINT8; +extern GrB_Semiring GxB_LAND_NE_UINT16; +extern GrB_Semiring GxB_LAND_NE_UINT32; +extern GrB_Semiring GxB_LAND_NE_UINT64; +extern GrB_Semiring GxB_LAND_PAIR_BOOL; +extern GrB_Semiring GxB_LAND_SECOND_BOOL; +extern GrB_Semiring GxB_LOR_EQ_BOOL; +extern GrB_Semiring GxB_LOR_EQ_FP32; +extern GrB_Semiring GxB_LOR_EQ_FP64; +extern GrB_Semiring GxB_LOR_EQ_INT8; +extern GrB_Semiring GxB_LOR_EQ_INT16; +extern GrB_Semiring GxB_LOR_EQ_INT32; +extern GrB_Semiring GxB_LOR_EQ_INT64; +extern GrB_Semiring GxB_LOR_EQ_UINT8; +extern GrB_Semiring GxB_LOR_EQ_UINT16; +extern GrB_Semiring GxB_LOR_EQ_UINT32; +extern GrB_Semiring GxB_LOR_EQ_UINT64; +extern GrB_Semiring GxB_LOR_FIRST_BOOL; +extern GrB_Semiring GxB_LOR_GE_BOOL; +extern GrB_Semiring GxB_LOR_GE_FP32; +extern GrB_Semiring GxB_LOR_GE_FP64; +extern GrB_Semiring GxB_LOR_GE_INT8; +extern GrB_Semiring GxB_LOR_GE_INT16; +extern GrB_Semiring GxB_LOR_GE_INT32; +extern GrB_Semiring GxB_LOR_GE_INT64; +extern GrB_Semiring GxB_LOR_GE_UINT8; +extern GrB_Semiring GxB_LOR_GE_UINT16; +extern GrB_Semiring GxB_LOR_GE_UINT32; +extern GrB_Semiring GxB_LOR_GE_UINT64; +extern GrB_Semiring GxB_LOR_GT_BOOL; +extern GrB_Semiring GxB_LOR_GT_FP32; +extern GrB_Semiring GxB_LOR_GT_FP64; +extern GrB_Semiring GxB_LOR_GT_INT8; +extern GrB_Semiring GxB_LOR_GT_INT16; +extern GrB_Semiring GxB_LOR_GT_INT32; +extern GrB_Semiring GxB_LOR_GT_INT64; +extern GrB_Semiring GxB_LOR_GT_UINT8; +extern GrB_Semiring GxB_LOR_GT_UINT16; +extern GrB_Semiring GxB_LOR_GT_UINT32; +extern GrB_Semiring GxB_LOR_GT_UINT64; +extern GrB_Semiring GxB_LOR_LE_BOOL; +extern GrB_Semiring GxB_LOR_LE_FP32; +extern GrB_Semiring GxB_LOR_LE_FP64; +extern GrB_Semiring GxB_LOR_LE_INT8; +extern GrB_Semiring GxB_LOR_LE_INT16; +extern GrB_Semiring GxB_LOR_LE_INT32; +extern GrB_Semiring GxB_LOR_LE_INT64; +extern GrB_Semiring GxB_LOR_LE_UINT8; +extern GrB_Semiring GxB_LOR_LE_UINT16; +extern GrB_Semiring GxB_LOR_LE_UINT32; +extern GrB_Semiring GxB_LOR_LE_UINT64; +extern GrB_Semiring GxB_LOR_LOR_BOOL; +extern GrB_Semiring GxB_LOR_LT_BOOL; +extern GrB_Semiring GxB_LOR_LT_FP32; +extern GrB_Semiring GxB_LOR_LT_FP64; +extern GrB_Semiring GxB_LOR_LT_INT8; +extern GrB_Semiring GxB_LOR_LT_INT16; +extern GrB_Semiring GxB_LOR_LT_INT32; +extern GrB_Semiring GxB_LOR_LT_INT64; +extern GrB_Semiring GxB_LOR_LT_UINT8; +extern GrB_Semiring GxB_LOR_LT_UINT16; +extern GrB_Semiring GxB_LOR_LT_UINT32; +extern GrB_Semiring GxB_LOR_LT_UINT64; +extern GrB_Semiring GxB_LOR_LXOR_BOOL; +extern GrB_Semiring GxB_LOR_NE_FP32; +extern GrB_Semiring GxB_LOR_NE_FP64; +extern GrB_Semiring GxB_LOR_NE_INT8; +extern GrB_Semiring GxB_LOR_NE_INT16; +extern GrB_Semiring GxB_LOR_NE_INT32; +extern GrB_Semiring GxB_LOR_NE_INT64; +extern GrB_Semiring GxB_LOR_NE_UINT8; +extern GrB_Semiring GxB_LOR_NE_UINT16; +extern GrB_Semiring GxB_LOR_NE_UINT32; +extern GrB_Semiring GxB_LOR_NE_UINT64; +extern GrB_Semiring GxB_LOR_PAIR_BOOL; +extern GrB_Semiring GxB_LOR_SECOND_BOOL; +extern GrB_Semiring GxB_LXOR_EQ_BOOL; +extern GrB_Semiring GxB_LXOR_EQ_FP32; +extern GrB_Semiring GxB_LXOR_EQ_FP64; +extern GrB_Semiring GxB_LXOR_EQ_INT8; +extern GrB_Semiring GxB_LXOR_EQ_INT16; +extern GrB_Semiring GxB_LXOR_EQ_INT32; +extern GrB_Semiring GxB_LXOR_EQ_INT64; +extern GrB_Semiring GxB_LXOR_EQ_UINT8; +extern GrB_Semiring GxB_LXOR_EQ_UINT16; +extern GrB_Semiring GxB_LXOR_EQ_UINT32; +extern GrB_Semiring GxB_LXOR_EQ_UINT64; +extern GrB_Semiring GxB_LXOR_FIRST_BOOL; +extern GrB_Semiring GxB_LXOR_GE_BOOL; +extern GrB_Semiring GxB_LXOR_GE_FP32; +extern GrB_Semiring GxB_LXOR_GE_FP64; +extern GrB_Semiring GxB_LXOR_GE_INT8; +extern GrB_Semiring GxB_LXOR_GE_INT16; +extern GrB_Semiring GxB_LXOR_GE_INT32; +extern GrB_Semiring GxB_LXOR_GE_INT64; +extern GrB_Semiring GxB_LXOR_GE_UINT8; +extern GrB_Semiring GxB_LXOR_GE_UINT16; +extern GrB_Semiring GxB_LXOR_GE_UINT32; +extern GrB_Semiring GxB_LXOR_GE_UINT64; +extern GrB_Semiring GxB_LXOR_GT_BOOL; +extern GrB_Semiring GxB_LXOR_GT_FP32; +extern GrB_Semiring GxB_LXOR_GT_FP64; +extern GrB_Semiring GxB_LXOR_GT_INT8; +extern GrB_Semiring GxB_LXOR_GT_INT16; +extern GrB_Semiring GxB_LXOR_GT_INT32; +extern GrB_Semiring GxB_LXOR_GT_INT64; +extern GrB_Semiring GxB_LXOR_GT_UINT8; +extern GrB_Semiring GxB_LXOR_GT_UINT16; +extern GrB_Semiring GxB_LXOR_GT_UINT32; +extern GrB_Semiring GxB_LXOR_GT_UINT64; +extern GrB_Semiring GxB_LXOR_LE_BOOL; +extern GrB_Semiring GxB_LXOR_LE_FP32; +extern GrB_Semiring GxB_LXOR_LE_FP64; +extern GrB_Semiring GxB_LXOR_LE_INT8; +extern GrB_Semiring GxB_LXOR_LE_INT16; +extern GrB_Semiring GxB_LXOR_LE_INT32; +extern GrB_Semiring GxB_LXOR_LE_INT64; +extern GrB_Semiring GxB_LXOR_LE_UINT8; +extern GrB_Semiring GxB_LXOR_LE_UINT16; +extern GrB_Semiring GxB_LXOR_LE_UINT32; +extern GrB_Semiring GxB_LXOR_LE_UINT64; +extern GrB_Semiring GxB_LXOR_LOR_BOOL; +extern GrB_Semiring GxB_LXOR_LT_BOOL; +extern GrB_Semiring GxB_LXOR_LT_FP32; +extern GrB_Semiring GxB_LXOR_LT_FP64; +extern GrB_Semiring GxB_LXOR_LT_INT8; +extern GrB_Semiring GxB_LXOR_LT_INT16; +extern GrB_Semiring GxB_LXOR_LT_INT32; +extern GrB_Semiring GxB_LXOR_LT_INT64; +extern GrB_Semiring GxB_LXOR_LT_UINT8; +extern GrB_Semiring GxB_LXOR_LT_UINT16; +extern GrB_Semiring GxB_LXOR_LT_UINT32; +extern GrB_Semiring GxB_LXOR_LT_UINT64; +extern GrB_Semiring GxB_LXOR_LXOR_BOOL; +extern GrB_Semiring GxB_LXOR_NE_FP32; +extern GrB_Semiring GxB_LXOR_NE_FP64; +extern GrB_Semiring GxB_LXOR_NE_INT8; +extern GrB_Semiring GxB_LXOR_NE_INT16; +extern GrB_Semiring GxB_LXOR_NE_INT32; +extern GrB_Semiring GxB_LXOR_NE_INT64; +extern GrB_Semiring GxB_LXOR_NE_UINT8; +extern GrB_Semiring GxB_LXOR_NE_UINT16; +extern GrB_Semiring GxB_LXOR_NE_UINT32; +extern GrB_Semiring GxB_LXOR_NE_UINT64; +extern GrB_Semiring GxB_LXOR_PAIR_BOOL; +extern GrB_Semiring GxB_LXOR_SECOND_BOOL; +extern GrB_Semiring GxB_MAX_DIV_FP32; +extern GrB_Semiring GxB_MAX_DIV_FP64; +extern GrB_Semiring GxB_MAX_DIV_INT8; +extern GrB_Semiring GxB_MAX_DIV_INT16; +extern GrB_Semiring GxB_MAX_DIV_INT32; +extern GrB_Semiring GxB_MAX_DIV_INT64; +extern GrB_Semiring GxB_MAX_DIV_UINT8; +extern GrB_Semiring GxB_MAX_DIV_UINT16; +extern GrB_Semiring GxB_MAX_DIV_UINT32; +extern GrB_Semiring GxB_MAX_DIV_UINT64; +extern GrB_Semiring GxB_MAX_FIRSTI1_INT32; +extern GrB_Semiring GxB_MAX_FIRSTI1_INT64; +extern GrB_Semiring GxB_MAX_FIRSTI_INT32; +extern GrB_Semiring GxB_MAX_FIRSTI_INT64; +extern GrB_Semiring GxB_MAX_FIRSTJ1_INT32; +extern GrB_Semiring GxB_MAX_FIRSTJ1_INT64; +extern GrB_Semiring GxB_MAX_FIRSTJ_INT32; +extern GrB_Semiring GxB_MAX_FIRSTJ_INT64; +extern GrB_Semiring GxB_MAX_ISEQ_FP32; +extern GrB_Semiring GxB_MAX_ISEQ_FP64; +extern GrB_Semiring GxB_MAX_ISEQ_INT8; +extern GrB_Semiring GxB_MAX_ISEQ_INT16; +extern GrB_Semiring GxB_MAX_ISEQ_INT32; +extern GrB_Semiring GxB_MAX_ISEQ_INT64; +extern GrB_Semiring GxB_MAX_ISEQ_UINT8; +extern GrB_Semiring GxB_MAX_ISEQ_UINT16; +extern GrB_Semiring GxB_MAX_ISEQ_UINT32; +extern GrB_Semiring GxB_MAX_ISEQ_UINT64; +extern GrB_Semiring GxB_MAX_ISGE_FP32; +extern GrB_Semiring GxB_MAX_ISGE_FP64; +extern GrB_Semiring GxB_MAX_ISGE_INT8; +extern GrB_Semiring GxB_MAX_ISGE_INT16; +extern GrB_Semiring GxB_MAX_ISGE_INT32; +extern GrB_Semiring GxB_MAX_ISGE_INT64; +extern GrB_Semiring GxB_MAX_ISGE_UINT8; +extern GrB_Semiring GxB_MAX_ISGE_UINT16; +extern GrB_Semiring GxB_MAX_ISGE_UINT32; +extern GrB_Semiring GxB_MAX_ISGE_UINT64; +extern GrB_Semiring GxB_MAX_ISGT_FP32; +extern GrB_Semiring GxB_MAX_ISGT_FP64; +extern GrB_Semiring GxB_MAX_ISGT_INT8; +extern GrB_Semiring GxB_MAX_ISGT_INT16; +extern GrB_Semiring GxB_MAX_ISGT_INT32; +extern GrB_Semiring GxB_MAX_ISGT_INT64; +extern GrB_Semiring GxB_MAX_ISGT_UINT8; +extern GrB_Semiring GxB_MAX_ISGT_UINT16; +extern GrB_Semiring GxB_MAX_ISGT_UINT32; +extern GrB_Semiring GxB_MAX_ISGT_UINT64; +extern GrB_Semiring GxB_MAX_ISLE_FP32; +extern GrB_Semiring GxB_MAX_ISLE_FP64; +extern GrB_Semiring GxB_MAX_ISLE_INT8; +extern GrB_Semiring GxB_MAX_ISLE_INT16; +extern GrB_Semiring GxB_MAX_ISLE_INT32; +extern GrB_Semiring GxB_MAX_ISLE_INT64; +extern GrB_Semiring GxB_MAX_ISLE_UINT8; +extern GrB_Semiring GxB_MAX_ISLE_UINT16; +extern GrB_Semiring GxB_MAX_ISLE_UINT32; +extern GrB_Semiring GxB_MAX_ISLE_UINT64; +extern GrB_Semiring GxB_MAX_ISLT_FP32; +extern GrB_Semiring GxB_MAX_ISLT_FP64; +extern GrB_Semiring GxB_MAX_ISLT_INT8; +extern GrB_Semiring GxB_MAX_ISLT_INT16; +extern GrB_Semiring GxB_MAX_ISLT_INT32; +extern GrB_Semiring GxB_MAX_ISLT_INT64; +extern GrB_Semiring GxB_MAX_ISLT_UINT8; +extern GrB_Semiring GxB_MAX_ISLT_UINT16; +extern GrB_Semiring GxB_MAX_ISLT_UINT32; +extern GrB_Semiring GxB_MAX_ISLT_UINT64; +extern GrB_Semiring GxB_MAX_ISNE_FP32; +extern GrB_Semiring GxB_MAX_ISNE_FP64; +extern GrB_Semiring GxB_MAX_ISNE_INT8; +extern GrB_Semiring GxB_MAX_ISNE_INT16; +extern GrB_Semiring GxB_MAX_ISNE_INT32; +extern GrB_Semiring GxB_MAX_ISNE_INT64; +extern GrB_Semiring GxB_MAX_ISNE_UINT8; +extern GrB_Semiring GxB_MAX_ISNE_UINT16; +extern GrB_Semiring GxB_MAX_ISNE_UINT32; +extern GrB_Semiring GxB_MAX_ISNE_UINT64; +extern GrB_Semiring GxB_MAX_LAND_FP32; +extern GrB_Semiring GxB_MAX_LAND_FP64; +extern GrB_Semiring GxB_MAX_LAND_INT8; +extern GrB_Semiring GxB_MAX_LAND_INT16; +extern GrB_Semiring GxB_MAX_LAND_INT32; +extern GrB_Semiring GxB_MAX_LAND_INT64; +extern GrB_Semiring GxB_MAX_LAND_UINT8; +extern GrB_Semiring GxB_MAX_LAND_UINT16; +extern GrB_Semiring GxB_MAX_LAND_UINT32; +extern GrB_Semiring GxB_MAX_LAND_UINT64; +extern GrB_Semiring GxB_MAX_LOR_FP32; +extern GrB_Semiring GxB_MAX_LOR_FP64; +extern GrB_Semiring GxB_MAX_LOR_INT8; +extern GrB_Semiring GxB_MAX_LOR_INT16; +extern GrB_Semiring GxB_MAX_LOR_INT32; +extern GrB_Semiring GxB_MAX_LOR_INT64; +extern GrB_Semiring GxB_MAX_LOR_UINT8; +extern GrB_Semiring GxB_MAX_LOR_UINT16; +extern GrB_Semiring GxB_MAX_LOR_UINT32; +extern GrB_Semiring GxB_MAX_LOR_UINT64; +extern GrB_Semiring GxB_MAX_LXOR_FP32; +extern GrB_Semiring GxB_MAX_LXOR_FP64; +extern GrB_Semiring GxB_MAX_LXOR_INT8; +extern GrB_Semiring GxB_MAX_LXOR_INT16; +extern GrB_Semiring GxB_MAX_LXOR_INT32; +extern GrB_Semiring GxB_MAX_LXOR_INT64; +extern GrB_Semiring GxB_MAX_LXOR_UINT8; +extern GrB_Semiring GxB_MAX_LXOR_UINT16; +extern GrB_Semiring GxB_MAX_LXOR_UINT32; +extern GrB_Semiring GxB_MAX_LXOR_UINT64; +extern GrB_Semiring GxB_MAX_MAX_FP32; +extern GrB_Semiring GxB_MAX_MAX_FP64; +extern GrB_Semiring GxB_MAX_MAX_INT8; +extern GrB_Semiring GxB_MAX_MAX_INT16; +extern GrB_Semiring GxB_MAX_MAX_INT32; +extern GrB_Semiring GxB_MAX_MAX_INT64; +extern GrB_Semiring GxB_MAX_MAX_UINT8; +extern GrB_Semiring GxB_MAX_MAX_UINT16; +extern GrB_Semiring GxB_MAX_MAX_UINT32; +extern GrB_Semiring GxB_MAX_MAX_UINT64; +extern GrB_Semiring GxB_MAX_MINUS_FP32; +extern GrB_Semiring GxB_MAX_MINUS_FP64; +extern GrB_Semiring GxB_MAX_MINUS_INT8; +extern GrB_Semiring GxB_MAX_MINUS_INT16; +extern GrB_Semiring GxB_MAX_MINUS_INT32; +extern GrB_Semiring GxB_MAX_MINUS_INT64; +extern GrB_Semiring GxB_MAX_MINUS_UINT8; +extern GrB_Semiring GxB_MAX_MINUS_UINT16; +extern GrB_Semiring GxB_MAX_MINUS_UINT32; +extern GrB_Semiring GxB_MAX_MINUS_UINT64; +extern GrB_Semiring GxB_MAX_PAIR_FP32; +extern GrB_Semiring GxB_MAX_PAIR_FP64; +extern GrB_Semiring GxB_MAX_PAIR_INT8; +extern GrB_Semiring GxB_MAX_PAIR_INT16; +extern GrB_Semiring GxB_MAX_PAIR_INT32; +extern GrB_Semiring GxB_MAX_PAIR_INT64; +extern GrB_Semiring GxB_MAX_PAIR_UINT8; +extern GrB_Semiring GxB_MAX_PAIR_UINT16; +extern GrB_Semiring GxB_MAX_PAIR_UINT32; +extern GrB_Semiring GxB_MAX_PAIR_UINT64; +extern GrB_Semiring GxB_MAX_RDIV_FP32; +extern GrB_Semiring GxB_MAX_RDIV_FP64; +extern GrB_Semiring GxB_MAX_RDIV_INT8; +extern GrB_Semiring GxB_MAX_RDIV_INT16; +extern GrB_Semiring GxB_MAX_RDIV_INT32; +extern GrB_Semiring GxB_MAX_RDIV_INT64; +extern GrB_Semiring GxB_MAX_RDIV_UINT8; +extern GrB_Semiring GxB_MAX_RDIV_UINT16; +extern GrB_Semiring GxB_MAX_RDIV_UINT32; +extern GrB_Semiring GxB_MAX_RDIV_UINT64; +extern GrB_Semiring GxB_MAX_RMINUS_FP32; +extern GrB_Semiring GxB_MAX_RMINUS_FP64; +extern GrB_Semiring GxB_MAX_RMINUS_INT8; +extern GrB_Semiring GxB_MAX_RMINUS_INT16; +extern GrB_Semiring GxB_MAX_RMINUS_INT32; +extern GrB_Semiring GxB_MAX_RMINUS_INT64; +extern GrB_Semiring GxB_MAX_RMINUS_UINT8; +extern GrB_Semiring GxB_MAX_RMINUS_UINT16; +extern GrB_Semiring GxB_MAX_RMINUS_UINT32; +extern GrB_Semiring GxB_MAX_RMINUS_UINT64; +extern GrB_Semiring GxB_MAX_SECONDI1_INT32; +extern GrB_Semiring GxB_MAX_SECONDI1_INT64; +extern GrB_Semiring GxB_MAX_SECONDI_INT32; +extern GrB_Semiring GxB_MAX_SECONDI_INT64; +extern GrB_Semiring GxB_MAX_SECONDJ1_INT32; +extern GrB_Semiring GxB_MAX_SECONDJ1_INT64; +extern GrB_Semiring GxB_MAX_SECONDJ_INT32; +extern GrB_Semiring GxB_MAX_SECONDJ_INT64; +extern GrB_Semiring GxB_MIN_DIV_FP32; +extern GrB_Semiring GxB_MIN_DIV_FP64; +extern GrB_Semiring GxB_MIN_DIV_INT8; +extern GrB_Semiring GxB_MIN_DIV_INT16; +extern GrB_Semiring GxB_MIN_DIV_INT32; +extern GrB_Semiring GxB_MIN_DIV_INT64; +extern GrB_Semiring GxB_MIN_DIV_UINT8; +extern GrB_Semiring GxB_MIN_DIV_UINT16; +extern GrB_Semiring GxB_MIN_DIV_UINT32; +extern GrB_Semiring GxB_MIN_DIV_UINT64; +extern GrB_Semiring GxB_MIN_FIRSTI1_INT32; +extern GrB_Semiring GxB_MIN_FIRSTI1_INT64; +extern GrB_Semiring GxB_MIN_FIRSTI_INT32; +extern GrB_Semiring GxB_MIN_FIRSTI_INT64; +extern GrB_Semiring GxB_MIN_FIRSTJ1_INT32; +extern GrB_Semiring GxB_MIN_FIRSTJ1_INT64; +extern GrB_Semiring GxB_MIN_FIRSTJ_INT32; +extern GrB_Semiring GxB_MIN_FIRSTJ_INT64; +extern GrB_Semiring GxB_MIN_ISEQ_FP32; +extern GrB_Semiring GxB_MIN_ISEQ_FP64; +extern GrB_Semiring GxB_MIN_ISEQ_INT8; +extern GrB_Semiring GxB_MIN_ISEQ_INT16; +extern GrB_Semiring GxB_MIN_ISEQ_INT32; +extern GrB_Semiring GxB_MIN_ISEQ_INT64; +extern GrB_Semiring GxB_MIN_ISEQ_UINT8; +extern GrB_Semiring GxB_MIN_ISEQ_UINT16; +extern GrB_Semiring GxB_MIN_ISEQ_UINT32; +extern GrB_Semiring GxB_MIN_ISEQ_UINT64; +extern GrB_Semiring GxB_MIN_ISGE_FP32; +extern GrB_Semiring GxB_MIN_ISGE_FP64; +extern GrB_Semiring GxB_MIN_ISGE_INT8; +extern GrB_Semiring GxB_MIN_ISGE_INT16; +extern GrB_Semiring GxB_MIN_ISGE_INT32; +extern GrB_Semiring GxB_MIN_ISGE_INT64; +extern GrB_Semiring GxB_MIN_ISGE_UINT8; +extern GrB_Semiring GxB_MIN_ISGE_UINT16; +extern GrB_Semiring GxB_MIN_ISGE_UINT32; +extern GrB_Semiring GxB_MIN_ISGE_UINT64; +extern GrB_Semiring GxB_MIN_ISGT_FP32; +extern GrB_Semiring GxB_MIN_ISGT_FP64; +extern GrB_Semiring GxB_MIN_ISGT_INT8; +extern GrB_Semiring GxB_MIN_ISGT_INT16; +extern GrB_Semiring GxB_MIN_ISGT_INT32; +extern GrB_Semiring GxB_MIN_ISGT_INT64; +extern GrB_Semiring GxB_MIN_ISGT_UINT8; +extern GrB_Semiring GxB_MIN_ISGT_UINT16; +extern GrB_Semiring GxB_MIN_ISGT_UINT32; +extern GrB_Semiring GxB_MIN_ISGT_UINT64; +extern GrB_Semiring GxB_MIN_ISLE_FP32; +extern GrB_Semiring GxB_MIN_ISLE_FP64; +extern GrB_Semiring GxB_MIN_ISLE_INT8; +extern GrB_Semiring GxB_MIN_ISLE_INT16; +extern GrB_Semiring GxB_MIN_ISLE_INT32; +extern GrB_Semiring GxB_MIN_ISLE_INT64; +extern GrB_Semiring GxB_MIN_ISLE_UINT8; +extern GrB_Semiring GxB_MIN_ISLE_UINT16; +extern GrB_Semiring GxB_MIN_ISLE_UINT32; +extern GrB_Semiring GxB_MIN_ISLE_UINT64; +extern GrB_Semiring GxB_MIN_ISLT_FP32; +extern GrB_Semiring GxB_MIN_ISLT_FP64; +extern GrB_Semiring GxB_MIN_ISLT_INT8; +extern GrB_Semiring GxB_MIN_ISLT_INT16; +extern GrB_Semiring GxB_MIN_ISLT_INT32; +extern GrB_Semiring GxB_MIN_ISLT_INT64; +extern GrB_Semiring GxB_MIN_ISLT_UINT8; +extern GrB_Semiring GxB_MIN_ISLT_UINT16; +extern GrB_Semiring GxB_MIN_ISLT_UINT32; +extern GrB_Semiring GxB_MIN_ISLT_UINT64; +extern GrB_Semiring GxB_MIN_ISNE_FP32; +extern GrB_Semiring GxB_MIN_ISNE_FP64; +extern GrB_Semiring GxB_MIN_ISNE_INT8; +extern GrB_Semiring GxB_MIN_ISNE_INT16; +extern GrB_Semiring GxB_MIN_ISNE_INT32; +extern GrB_Semiring GxB_MIN_ISNE_INT64; +extern GrB_Semiring GxB_MIN_ISNE_UINT8; +extern GrB_Semiring GxB_MIN_ISNE_UINT16; +extern GrB_Semiring GxB_MIN_ISNE_UINT32; +extern GrB_Semiring GxB_MIN_ISNE_UINT64; +extern GrB_Semiring GxB_MIN_LAND_FP32; +extern GrB_Semiring GxB_MIN_LAND_FP64; +extern GrB_Semiring GxB_MIN_LAND_INT8; +extern GrB_Semiring GxB_MIN_LAND_INT16; +extern GrB_Semiring GxB_MIN_LAND_INT32; +extern GrB_Semiring GxB_MIN_LAND_INT64; +extern GrB_Semiring GxB_MIN_LAND_UINT8; +extern GrB_Semiring GxB_MIN_LAND_UINT16; +extern GrB_Semiring GxB_MIN_LAND_UINT32; +extern GrB_Semiring GxB_MIN_LAND_UINT64; +extern GrB_Semiring GxB_MIN_LOR_FP32; +extern GrB_Semiring GxB_MIN_LOR_FP64; +extern GrB_Semiring GxB_MIN_LOR_INT8; +extern GrB_Semiring GxB_MIN_LOR_INT16; +extern GrB_Semiring GxB_MIN_LOR_INT32; +extern GrB_Semiring GxB_MIN_LOR_INT64; +extern GrB_Semiring GxB_MIN_LOR_UINT8; +extern GrB_Semiring GxB_MIN_LOR_UINT16; +extern GrB_Semiring GxB_MIN_LOR_UINT32; +extern GrB_Semiring GxB_MIN_LOR_UINT64; +extern GrB_Semiring GxB_MIN_LXOR_FP32; +extern GrB_Semiring GxB_MIN_LXOR_FP64; +extern GrB_Semiring GxB_MIN_LXOR_INT8; +extern GrB_Semiring GxB_MIN_LXOR_INT16; +extern GrB_Semiring GxB_MIN_LXOR_INT32; +extern GrB_Semiring GxB_MIN_LXOR_INT64; +extern GrB_Semiring GxB_MIN_LXOR_UINT8; +extern GrB_Semiring GxB_MIN_LXOR_UINT16; +extern GrB_Semiring GxB_MIN_LXOR_UINT32; +extern GrB_Semiring GxB_MIN_LXOR_UINT64; +extern GrB_Semiring GxB_MIN_MINUS_FP32; +extern GrB_Semiring GxB_MIN_MINUS_FP64; +extern GrB_Semiring GxB_MIN_MINUS_INT8; +extern GrB_Semiring GxB_MIN_MINUS_INT16; +extern GrB_Semiring GxB_MIN_MINUS_INT32; +extern GrB_Semiring GxB_MIN_MINUS_INT64; +extern GrB_Semiring GxB_MIN_MINUS_UINT8; +extern GrB_Semiring GxB_MIN_MINUS_UINT16; +extern GrB_Semiring GxB_MIN_MINUS_UINT32; +extern GrB_Semiring GxB_MIN_MINUS_UINT64; +extern GrB_Semiring GxB_MIN_MIN_FP32; +extern GrB_Semiring GxB_MIN_MIN_FP64; +extern GrB_Semiring GxB_MIN_MIN_INT8; +extern GrB_Semiring GxB_MIN_MIN_INT16; +extern GrB_Semiring GxB_MIN_MIN_INT32; +extern GrB_Semiring GxB_MIN_MIN_INT64; +extern GrB_Semiring GxB_MIN_MIN_UINT8; +extern GrB_Semiring GxB_MIN_MIN_UINT16; +extern GrB_Semiring GxB_MIN_MIN_UINT32; +extern GrB_Semiring GxB_MIN_MIN_UINT64; +extern GrB_Semiring GxB_MIN_PAIR_FP32; +extern GrB_Semiring GxB_MIN_PAIR_FP64; +extern GrB_Semiring GxB_MIN_PAIR_INT8; +extern GrB_Semiring GxB_MIN_PAIR_INT16; +extern GrB_Semiring GxB_MIN_PAIR_INT32; +extern GrB_Semiring GxB_MIN_PAIR_INT64; +extern GrB_Semiring GxB_MIN_PAIR_UINT8; +extern GrB_Semiring GxB_MIN_PAIR_UINT16; +extern GrB_Semiring GxB_MIN_PAIR_UINT32; +extern GrB_Semiring GxB_MIN_PAIR_UINT64; +extern GrB_Semiring GxB_MIN_RDIV_FP32; +extern GrB_Semiring GxB_MIN_RDIV_FP64; +extern GrB_Semiring GxB_MIN_RDIV_INT8; +extern GrB_Semiring GxB_MIN_RDIV_INT16; +extern GrB_Semiring GxB_MIN_RDIV_INT32; +extern GrB_Semiring GxB_MIN_RDIV_INT64; +extern GrB_Semiring GxB_MIN_RDIV_UINT8; +extern GrB_Semiring GxB_MIN_RDIV_UINT16; +extern GrB_Semiring GxB_MIN_RDIV_UINT32; +extern GrB_Semiring GxB_MIN_RDIV_UINT64; +extern GrB_Semiring GxB_MIN_RMINUS_FP32; +extern GrB_Semiring GxB_MIN_RMINUS_FP64; +extern GrB_Semiring GxB_MIN_RMINUS_INT8; +extern GrB_Semiring GxB_MIN_RMINUS_INT16; +extern GrB_Semiring GxB_MIN_RMINUS_INT32; +extern GrB_Semiring GxB_MIN_RMINUS_INT64; +extern GrB_Semiring GxB_MIN_RMINUS_UINT8; +extern GrB_Semiring GxB_MIN_RMINUS_UINT16; +extern GrB_Semiring GxB_MIN_RMINUS_UINT32; +extern GrB_Semiring GxB_MIN_RMINUS_UINT64; +extern GrB_Semiring GxB_MIN_SECONDI1_INT32; +extern GrB_Semiring GxB_MIN_SECONDI1_INT64; +extern GrB_Semiring GxB_MIN_SECONDI_INT32; +extern GrB_Semiring GxB_MIN_SECONDI_INT64; +extern GrB_Semiring GxB_MIN_SECONDJ1_INT32; +extern GrB_Semiring GxB_MIN_SECONDJ1_INT64; +extern GrB_Semiring GxB_MIN_SECONDJ_INT32; +extern GrB_Semiring GxB_MIN_SECONDJ_INT64; +extern GrB_Semiring GxB_PLUS_DIV_FP32; +extern GrB_Semiring GxB_PLUS_DIV_FP64; +extern GrB_Semiring GxB_PLUS_DIV_INT8; +extern GrB_Semiring GxB_PLUS_DIV_INT16; +extern GrB_Semiring GxB_PLUS_DIV_INT32; +extern GrB_Semiring GxB_PLUS_DIV_INT64; +extern GrB_Semiring GxB_PLUS_DIV_UINT8; +extern GrB_Semiring GxB_PLUS_DIV_UINT16; +extern GrB_Semiring GxB_PLUS_DIV_UINT32; +extern GrB_Semiring GxB_PLUS_DIV_UINT64; +extern GrB_Semiring GxB_PLUS_FIRSTI1_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTI1_INT64; +extern GrB_Semiring GxB_PLUS_FIRSTI_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTI_INT64; +extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTJ1_INT64; +extern GrB_Semiring GxB_PLUS_FIRSTJ_INT32; +extern GrB_Semiring GxB_PLUS_FIRSTJ_INT64; +extern GrB_Semiring GxB_PLUS_FIRST_FP32; +extern GrB_Semiring GxB_PLUS_FIRST_FP64; +extern GrB_Semiring GxB_PLUS_FIRST_INT8; +extern GrB_Semiring GxB_PLUS_FIRST_INT16; +extern GrB_Semiring GxB_PLUS_FIRST_INT32; +extern GrB_Semiring GxB_PLUS_FIRST_INT64; +extern GrB_Semiring GxB_PLUS_FIRST_UINT8; +extern GrB_Semiring GxB_PLUS_FIRST_UINT16; +extern GrB_Semiring GxB_PLUS_FIRST_UINT32; +extern GrB_Semiring GxB_PLUS_FIRST_UINT64; +extern GrB_Semiring GxB_PLUS_ISEQ_FP32; +extern GrB_Semiring GxB_PLUS_ISEQ_FP64; +extern GrB_Semiring GxB_PLUS_ISEQ_INT8; +extern GrB_Semiring GxB_PLUS_ISEQ_INT16; +extern GrB_Semiring GxB_PLUS_ISEQ_INT32; +extern GrB_Semiring GxB_PLUS_ISEQ_INT64; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT8; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT16; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT32; +extern GrB_Semiring GxB_PLUS_ISEQ_UINT64; +extern GrB_Semiring GxB_PLUS_ISGE_FP32; +extern GrB_Semiring GxB_PLUS_ISGE_FP64; +extern GrB_Semiring GxB_PLUS_ISGE_INT8; +extern GrB_Semiring GxB_PLUS_ISGE_INT16; +extern GrB_Semiring GxB_PLUS_ISGE_INT32; +extern GrB_Semiring GxB_PLUS_ISGE_INT64; +extern GrB_Semiring GxB_PLUS_ISGE_UINT8; +extern GrB_Semiring GxB_PLUS_ISGE_UINT16; +extern GrB_Semiring GxB_PLUS_ISGE_UINT32; +extern GrB_Semiring GxB_PLUS_ISGE_UINT64; +extern GrB_Semiring GxB_PLUS_ISGT_FP32; +extern GrB_Semiring GxB_PLUS_ISGT_FP64; +extern GrB_Semiring GxB_PLUS_ISGT_INT8; +extern GrB_Semiring GxB_PLUS_ISGT_INT16; +extern GrB_Semiring GxB_PLUS_ISGT_INT32; +extern GrB_Semiring GxB_PLUS_ISGT_INT64; +extern GrB_Semiring GxB_PLUS_ISGT_UINT8; +extern GrB_Semiring GxB_PLUS_ISGT_UINT16; +extern GrB_Semiring GxB_PLUS_ISGT_UINT32; +extern GrB_Semiring GxB_PLUS_ISGT_UINT64; +extern GrB_Semiring GxB_PLUS_ISLE_FP32; +extern GrB_Semiring GxB_PLUS_ISLE_FP64; +extern GrB_Semiring GxB_PLUS_ISLE_INT8; +extern GrB_Semiring GxB_PLUS_ISLE_INT16; +extern GrB_Semiring GxB_PLUS_ISLE_INT32; +extern GrB_Semiring GxB_PLUS_ISLE_INT64; +extern GrB_Semiring GxB_PLUS_ISLE_UINT8; +extern GrB_Semiring GxB_PLUS_ISLE_UINT16; +extern GrB_Semiring GxB_PLUS_ISLE_UINT32; +extern GrB_Semiring GxB_PLUS_ISLE_UINT64; +extern GrB_Semiring GxB_PLUS_ISLT_FP32; +extern GrB_Semiring GxB_PLUS_ISLT_FP64; +extern GrB_Semiring GxB_PLUS_ISLT_INT8; +extern GrB_Semiring GxB_PLUS_ISLT_INT16; +extern GrB_Semiring GxB_PLUS_ISLT_INT32; +extern GrB_Semiring GxB_PLUS_ISLT_INT64; +extern GrB_Semiring GxB_PLUS_ISLT_UINT8; +extern GrB_Semiring GxB_PLUS_ISLT_UINT16; +extern GrB_Semiring GxB_PLUS_ISLT_UINT32; +extern GrB_Semiring GxB_PLUS_ISLT_UINT64; +extern GrB_Semiring GxB_PLUS_ISNE_FP32; +extern GrB_Semiring GxB_PLUS_ISNE_FP64; +extern GrB_Semiring GxB_PLUS_ISNE_INT8; +extern GrB_Semiring GxB_PLUS_ISNE_INT16; +extern GrB_Semiring GxB_PLUS_ISNE_INT32; +extern GrB_Semiring GxB_PLUS_ISNE_INT64; +extern GrB_Semiring GxB_PLUS_ISNE_UINT8; +extern GrB_Semiring GxB_PLUS_ISNE_UINT16; +extern GrB_Semiring GxB_PLUS_ISNE_UINT32; +extern GrB_Semiring GxB_PLUS_ISNE_UINT64; +extern GrB_Semiring GxB_PLUS_LAND_FP32; +extern GrB_Semiring GxB_PLUS_LAND_FP64; +extern GrB_Semiring GxB_PLUS_LAND_INT8; +extern GrB_Semiring GxB_PLUS_LAND_INT16; +extern GrB_Semiring GxB_PLUS_LAND_INT32; +extern GrB_Semiring GxB_PLUS_LAND_INT64; +extern GrB_Semiring GxB_PLUS_LAND_UINT8; +extern GrB_Semiring GxB_PLUS_LAND_UINT16; +extern GrB_Semiring GxB_PLUS_LAND_UINT32; +extern GrB_Semiring GxB_PLUS_LAND_UINT64; +extern GrB_Semiring GxB_PLUS_LOR_FP32; +extern GrB_Semiring GxB_PLUS_LOR_FP64; +extern GrB_Semiring GxB_PLUS_LOR_INT8; +extern GrB_Semiring GxB_PLUS_LOR_INT16; +extern GrB_Semiring GxB_PLUS_LOR_INT32; +extern GrB_Semiring GxB_PLUS_LOR_INT64; +extern GrB_Semiring GxB_PLUS_LOR_UINT8; +extern GrB_Semiring GxB_PLUS_LOR_UINT16; +extern GrB_Semiring GxB_PLUS_LOR_UINT32; +extern GrB_Semiring GxB_PLUS_LOR_UINT64; +extern GrB_Semiring GxB_PLUS_LXOR_FP32; +extern GrB_Semiring GxB_PLUS_LXOR_FP64; +extern GrB_Semiring GxB_PLUS_LXOR_INT8; +extern GrB_Semiring GxB_PLUS_LXOR_INT16; +extern GrB_Semiring GxB_PLUS_LXOR_INT32; +extern GrB_Semiring GxB_PLUS_LXOR_INT64; +extern GrB_Semiring GxB_PLUS_LXOR_UINT8; +extern GrB_Semiring GxB_PLUS_LXOR_UINT16; +extern GrB_Semiring GxB_PLUS_LXOR_UINT32; +extern GrB_Semiring GxB_PLUS_LXOR_UINT64; +extern GrB_Semiring GxB_PLUS_MAX_FP32; +extern GrB_Semiring GxB_PLUS_MAX_FP64; +extern GrB_Semiring GxB_PLUS_MAX_INT8; +extern GrB_Semiring GxB_PLUS_MAX_INT16; +extern GrB_Semiring GxB_PLUS_MAX_INT32; +extern GrB_Semiring GxB_PLUS_MAX_INT64; +extern GrB_Semiring GxB_PLUS_MAX_UINT8; +extern GrB_Semiring GxB_PLUS_MAX_UINT16; +extern GrB_Semiring GxB_PLUS_MAX_UINT32; +extern GrB_Semiring GxB_PLUS_MAX_UINT64; +extern GrB_Semiring GxB_PLUS_MINUS_FP32; +extern GrB_Semiring GxB_PLUS_MINUS_FP64; +extern GrB_Semiring GxB_PLUS_MINUS_INT8; +extern GrB_Semiring GxB_PLUS_MINUS_INT16; +extern GrB_Semiring GxB_PLUS_MINUS_INT32; +extern GrB_Semiring GxB_PLUS_MINUS_INT64; +extern GrB_Semiring GxB_PLUS_MINUS_UINT8; +extern GrB_Semiring GxB_PLUS_MINUS_UINT16; +extern GrB_Semiring GxB_PLUS_MINUS_UINT32; +extern GrB_Semiring GxB_PLUS_MINUS_UINT64; +extern GrB_Semiring GxB_PLUS_PAIR_FP32; +extern GrB_Semiring GxB_PLUS_PAIR_FP64; +extern GrB_Semiring GxB_PLUS_PAIR_INT8; +extern GrB_Semiring GxB_PLUS_PAIR_INT16; +extern GrB_Semiring GxB_PLUS_PAIR_INT32; +extern GrB_Semiring GxB_PLUS_PAIR_INT64; +extern GrB_Semiring GxB_PLUS_PAIR_UINT8; +extern GrB_Semiring GxB_PLUS_PAIR_UINT16; +extern GrB_Semiring GxB_PLUS_PAIR_UINT32; +extern GrB_Semiring GxB_PLUS_PAIR_UINT64; +extern GrB_Semiring GxB_PLUS_PLUS_FP32; +extern GrB_Semiring GxB_PLUS_PLUS_FP64; +extern GrB_Semiring GxB_PLUS_PLUS_INT8; +extern GrB_Semiring GxB_PLUS_PLUS_INT16; +extern GrB_Semiring GxB_PLUS_PLUS_INT32; +extern GrB_Semiring GxB_PLUS_PLUS_INT64; +extern GrB_Semiring GxB_PLUS_PLUS_UINT8; +extern GrB_Semiring GxB_PLUS_PLUS_UINT16; +extern GrB_Semiring GxB_PLUS_PLUS_UINT32; +extern GrB_Semiring GxB_PLUS_PLUS_UINT64; +extern GrB_Semiring GxB_PLUS_RDIV_FP32; +extern GrB_Semiring GxB_PLUS_RDIV_FP64; +extern GrB_Semiring GxB_PLUS_RDIV_INT8; +extern GrB_Semiring GxB_PLUS_RDIV_INT16; +extern GrB_Semiring GxB_PLUS_RDIV_INT32; +extern GrB_Semiring GxB_PLUS_RDIV_INT64; +extern GrB_Semiring GxB_PLUS_RDIV_UINT8; +extern GrB_Semiring GxB_PLUS_RDIV_UINT16; +extern GrB_Semiring GxB_PLUS_RDIV_UINT32; +extern GrB_Semiring GxB_PLUS_RDIV_UINT64; +extern GrB_Semiring GxB_PLUS_RMINUS_FP32; +extern GrB_Semiring GxB_PLUS_RMINUS_FP64; +extern GrB_Semiring GxB_PLUS_RMINUS_INT8; +extern GrB_Semiring GxB_PLUS_RMINUS_INT16; +extern GrB_Semiring GxB_PLUS_RMINUS_INT32; +extern GrB_Semiring GxB_PLUS_RMINUS_INT64; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT8; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT16; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT32; +extern GrB_Semiring GxB_PLUS_RMINUS_UINT64; +extern GrB_Semiring GxB_PLUS_SECONDI1_INT32; +extern GrB_Semiring GxB_PLUS_SECONDI1_INT64; +extern GrB_Semiring GxB_PLUS_SECONDI_INT32; +extern GrB_Semiring GxB_PLUS_SECONDI_INT64; +extern GrB_Semiring GxB_PLUS_SECONDJ1_INT32; +extern GrB_Semiring GxB_PLUS_SECONDJ1_INT64; +extern GrB_Semiring GxB_PLUS_SECONDJ_INT32; +extern GrB_Semiring GxB_PLUS_SECONDJ_INT64; +extern GrB_Semiring GxB_PLUS_SECOND_FP32; +extern GrB_Semiring GxB_PLUS_SECOND_FP64; +extern GrB_Semiring GxB_PLUS_SECOND_INT8; +extern GrB_Semiring GxB_PLUS_SECOND_INT16; +extern GrB_Semiring GxB_PLUS_SECOND_INT32; +extern GrB_Semiring GxB_PLUS_SECOND_INT64; +extern GrB_Semiring GxB_PLUS_SECOND_UINT8; +extern GrB_Semiring GxB_PLUS_SECOND_UINT16; +extern GrB_Semiring GxB_PLUS_SECOND_UINT32; +extern GrB_Semiring GxB_PLUS_SECOND_UINT64; +extern GrB_Semiring GxB_TIMES_DIV_FP32; +extern GrB_Semiring GxB_TIMES_DIV_FP64; +extern GrB_Semiring GxB_TIMES_DIV_INT8; +extern GrB_Semiring GxB_TIMES_DIV_INT16; +extern GrB_Semiring GxB_TIMES_DIV_INT32; +extern GrB_Semiring GxB_TIMES_DIV_INT64; +extern GrB_Semiring GxB_TIMES_DIV_UINT8; +extern GrB_Semiring GxB_TIMES_DIV_UINT16; +extern GrB_Semiring GxB_TIMES_DIV_UINT32; +extern GrB_Semiring GxB_TIMES_DIV_UINT64; +extern GrB_Semiring GxB_TIMES_FIRSTI1_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTI1_INT64; +extern GrB_Semiring GxB_TIMES_FIRSTI_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTI_INT64; +extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTJ1_INT64; +extern GrB_Semiring GxB_TIMES_FIRSTJ_INT32; +extern GrB_Semiring GxB_TIMES_FIRSTJ_INT64; +extern GrB_Semiring GxB_TIMES_FIRST_FP32; +extern GrB_Semiring GxB_TIMES_FIRST_FP64; +extern GrB_Semiring GxB_TIMES_FIRST_INT8; +extern GrB_Semiring GxB_TIMES_FIRST_INT16; +extern GrB_Semiring GxB_TIMES_FIRST_INT32; +extern GrB_Semiring GxB_TIMES_FIRST_INT64; +extern GrB_Semiring GxB_TIMES_FIRST_UINT8; +extern GrB_Semiring GxB_TIMES_FIRST_UINT16; +extern GrB_Semiring GxB_TIMES_FIRST_UINT32; +extern GrB_Semiring GxB_TIMES_FIRST_UINT64; +extern GrB_Semiring GxB_TIMES_ISEQ_FP32; +extern GrB_Semiring GxB_TIMES_ISEQ_FP64; +extern GrB_Semiring GxB_TIMES_ISEQ_INT8; +extern GrB_Semiring GxB_TIMES_ISEQ_INT16; +extern GrB_Semiring GxB_TIMES_ISEQ_INT32; +extern GrB_Semiring GxB_TIMES_ISEQ_INT64; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT8; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT16; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT32; +extern GrB_Semiring GxB_TIMES_ISEQ_UINT64; +extern GrB_Semiring GxB_TIMES_ISGE_FP32; +extern GrB_Semiring GxB_TIMES_ISGE_FP64; +extern GrB_Semiring GxB_TIMES_ISGE_INT8; +extern GrB_Semiring GxB_TIMES_ISGE_INT16; +extern GrB_Semiring GxB_TIMES_ISGE_INT32; +extern GrB_Semiring GxB_TIMES_ISGE_INT64; +extern GrB_Semiring GxB_TIMES_ISGE_UINT8; +extern GrB_Semiring GxB_TIMES_ISGE_UINT16; +extern GrB_Semiring GxB_TIMES_ISGE_UINT32; +extern GrB_Semiring GxB_TIMES_ISGE_UINT64; +extern GrB_Semiring GxB_TIMES_ISGT_FP32; +extern GrB_Semiring GxB_TIMES_ISGT_FP64; +extern GrB_Semiring GxB_TIMES_ISGT_INT8; +extern GrB_Semiring GxB_TIMES_ISGT_INT16; +extern GrB_Semiring GxB_TIMES_ISGT_INT32; +extern GrB_Semiring GxB_TIMES_ISGT_INT64; +extern GrB_Semiring GxB_TIMES_ISGT_UINT8; +extern GrB_Semiring GxB_TIMES_ISGT_UINT16; +extern GrB_Semiring GxB_TIMES_ISGT_UINT32; +extern GrB_Semiring GxB_TIMES_ISGT_UINT64; +extern GrB_Semiring GxB_TIMES_ISLE_FP32; +extern GrB_Semiring GxB_TIMES_ISLE_FP64; +extern GrB_Semiring GxB_TIMES_ISLE_INT8; +extern GrB_Semiring GxB_TIMES_ISLE_INT16; +extern GrB_Semiring GxB_TIMES_ISLE_INT32; +extern GrB_Semiring GxB_TIMES_ISLE_INT64; +extern GrB_Semiring GxB_TIMES_ISLE_UINT8; +extern GrB_Semiring GxB_TIMES_ISLE_UINT16; +extern GrB_Semiring GxB_TIMES_ISLE_UINT32; +extern GrB_Semiring GxB_TIMES_ISLE_UINT64; +extern GrB_Semiring GxB_TIMES_ISLT_FP32; +extern GrB_Semiring GxB_TIMES_ISLT_FP64; +extern GrB_Semiring GxB_TIMES_ISLT_INT8; +extern GrB_Semiring GxB_TIMES_ISLT_INT16; +extern GrB_Semiring GxB_TIMES_ISLT_INT32; +extern GrB_Semiring GxB_TIMES_ISLT_INT64; +extern GrB_Semiring GxB_TIMES_ISLT_UINT8; +extern GrB_Semiring GxB_TIMES_ISLT_UINT16; +extern GrB_Semiring GxB_TIMES_ISLT_UINT32; +extern GrB_Semiring GxB_TIMES_ISLT_UINT64; +extern GrB_Semiring GxB_TIMES_ISNE_FP32; +extern GrB_Semiring GxB_TIMES_ISNE_FP64; +extern GrB_Semiring GxB_TIMES_ISNE_INT8; +extern GrB_Semiring GxB_TIMES_ISNE_INT16; +extern GrB_Semiring GxB_TIMES_ISNE_INT32; +extern GrB_Semiring GxB_TIMES_ISNE_INT64; +extern GrB_Semiring GxB_TIMES_ISNE_UINT8; +extern GrB_Semiring GxB_TIMES_ISNE_UINT16; +extern GrB_Semiring GxB_TIMES_ISNE_UINT32; +extern GrB_Semiring GxB_TIMES_ISNE_UINT64; +extern GrB_Semiring GxB_TIMES_LAND_FP32; +extern GrB_Semiring GxB_TIMES_LAND_FP64; +extern GrB_Semiring GxB_TIMES_LAND_INT8; +extern GrB_Semiring GxB_TIMES_LAND_INT16; +extern GrB_Semiring GxB_TIMES_LAND_INT32; +extern GrB_Semiring GxB_TIMES_LAND_INT64; +extern GrB_Semiring GxB_TIMES_LAND_UINT8; +extern GrB_Semiring GxB_TIMES_LAND_UINT16; +extern GrB_Semiring GxB_TIMES_LAND_UINT32; +extern GrB_Semiring GxB_TIMES_LAND_UINT64; +extern GrB_Semiring GxB_TIMES_LOR_FP32; +extern GrB_Semiring GxB_TIMES_LOR_FP64; +extern GrB_Semiring GxB_TIMES_LOR_INT8; +extern GrB_Semiring GxB_TIMES_LOR_INT16; +extern GrB_Semiring GxB_TIMES_LOR_INT32; +extern GrB_Semiring GxB_TIMES_LOR_INT64; +extern GrB_Semiring GxB_TIMES_LOR_UINT8; +extern GrB_Semiring GxB_TIMES_LOR_UINT16; +extern GrB_Semiring GxB_TIMES_LOR_UINT32; +extern GrB_Semiring GxB_TIMES_LOR_UINT64; +extern GrB_Semiring GxB_TIMES_LXOR_FP32; +extern GrB_Semiring GxB_TIMES_LXOR_FP64; +extern GrB_Semiring GxB_TIMES_LXOR_INT8; +extern GrB_Semiring GxB_TIMES_LXOR_INT16; +extern GrB_Semiring GxB_TIMES_LXOR_INT32; +extern GrB_Semiring GxB_TIMES_LXOR_INT64; +extern GrB_Semiring GxB_TIMES_LXOR_UINT8; +extern GrB_Semiring GxB_TIMES_LXOR_UINT16; +extern GrB_Semiring GxB_TIMES_LXOR_UINT32; +extern GrB_Semiring GxB_TIMES_LXOR_UINT64; +extern GrB_Semiring GxB_TIMES_MAX_FP32; +extern GrB_Semiring GxB_TIMES_MAX_FP64; +extern GrB_Semiring GxB_TIMES_MAX_INT8; +extern GrB_Semiring GxB_TIMES_MAX_INT16; +extern GrB_Semiring GxB_TIMES_MAX_INT32; +extern GrB_Semiring GxB_TIMES_MAX_INT64; +extern GrB_Semiring GxB_TIMES_MAX_UINT8; +extern GrB_Semiring GxB_TIMES_MAX_UINT16; +extern GrB_Semiring GxB_TIMES_MAX_UINT32; +extern GrB_Semiring GxB_TIMES_MAX_UINT64; +extern GrB_Semiring GxB_TIMES_MINUS_FP32; +extern GrB_Semiring GxB_TIMES_MINUS_FP64; +extern GrB_Semiring GxB_TIMES_MINUS_INT8; +extern GrB_Semiring GxB_TIMES_MINUS_INT16; +extern GrB_Semiring GxB_TIMES_MINUS_INT32; +extern GrB_Semiring GxB_TIMES_MINUS_INT64; +extern GrB_Semiring GxB_TIMES_MINUS_UINT8; +extern GrB_Semiring GxB_TIMES_MINUS_UINT16; +extern GrB_Semiring GxB_TIMES_MINUS_UINT32; +extern GrB_Semiring GxB_TIMES_MINUS_UINT64; +extern GrB_Semiring GxB_TIMES_MIN_FP32; +extern GrB_Semiring GxB_TIMES_MIN_FP64; +extern GrB_Semiring GxB_TIMES_MIN_INT8; +extern GrB_Semiring GxB_TIMES_MIN_INT16; +extern GrB_Semiring GxB_TIMES_MIN_INT32; +extern GrB_Semiring GxB_TIMES_MIN_INT64; +extern GrB_Semiring GxB_TIMES_MIN_UINT8; +extern GrB_Semiring GxB_TIMES_MIN_UINT16; +extern GrB_Semiring GxB_TIMES_MIN_UINT32; +extern GrB_Semiring GxB_TIMES_MIN_UINT64; +extern GrB_Semiring GxB_TIMES_PAIR_FP32; +extern GrB_Semiring GxB_TIMES_PAIR_FP64; +extern GrB_Semiring GxB_TIMES_PAIR_INT8; +extern GrB_Semiring GxB_TIMES_PAIR_INT16; +extern GrB_Semiring GxB_TIMES_PAIR_INT32; +extern GrB_Semiring GxB_TIMES_PAIR_INT64; +extern GrB_Semiring GxB_TIMES_PAIR_UINT8; +extern GrB_Semiring GxB_TIMES_PAIR_UINT16; +extern GrB_Semiring GxB_TIMES_PAIR_UINT32; +extern GrB_Semiring GxB_TIMES_PAIR_UINT64; +extern GrB_Semiring GxB_TIMES_PLUS_FP32; +extern GrB_Semiring GxB_TIMES_PLUS_FP64; +extern GrB_Semiring GxB_TIMES_PLUS_INT8; +extern GrB_Semiring GxB_TIMES_PLUS_INT16; +extern GrB_Semiring GxB_TIMES_PLUS_INT32; +extern GrB_Semiring GxB_TIMES_PLUS_INT64; +extern GrB_Semiring GxB_TIMES_PLUS_UINT8; +extern GrB_Semiring GxB_TIMES_PLUS_UINT16; +extern GrB_Semiring GxB_TIMES_PLUS_UINT32; +extern GrB_Semiring GxB_TIMES_PLUS_UINT64; +extern GrB_Semiring GxB_TIMES_RDIV_FP32; +extern GrB_Semiring GxB_TIMES_RDIV_FP64; +extern GrB_Semiring GxB_TIMES_RDIV_INT8; +extern GrB_Semiring GxB_TIMES_RDIV_INT16; +extern GrB_Semiring GxB_TIMES_RDIV_INT32; +extern GrB_Semiring GxB_TIMES_RDIV_INT64; +extern GrB_Semiring GxB_TIMES_RDIV_UINT8; +extern GrB_Semiring GxB_TIMES_RDIV_UINT16; +extern GrB_Semiring GxB_TIMES_RDIV_UINT32; +extern GrB_Semiring GxB_TIMES_RDIV_UINT64; +extern GrB_Semiring GxB_TIMES_RMINUS_FP32; +extern GrB_Semiring GxB_TIMES_RMINUS_FP64; +extern GrB_Semiring GxB_TIMES_RMINUS_INT8; +extern GrB_Semiring GxB_TIMES_RMINUS_INT16; +extern GrB_Semiring GxB_TIMES_RMINUS_INT32; +extern GrB_Semiring GxB_TIMES_RMINUS_INT64; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT8; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT16; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT32; +extern GrB_Semiring GxB_TIMES_RMINUS_UINT64; +extern GrB_Semiring GxB_TIMES_SECONDI1_INT32; +extern GrB_Semiring GxB_TIMES_SECONDI1_INT64; +extern GrB_Semiring GxB_TIMES_SECONDI_INT32; +extern GrB_Semiring GxB_TIMES_SECONDI_INT64; +extern GrB_Semiring GxB_TIMES_SECONDJ1_INT32; +extern GrB_Semiring GxB_TIMES_SECONDJ1_INT64; +extern GrB_Semiring GxB_TIMES_SECONDJ_INT32; +extern GrB_Semiring GxB_TIMES_SECONDJ_INT64; +extern GrB_Semiring GxB_TIMES_SECOND_FP32; +extern GrB_Semiring GxB_TIMES_SECOND_FP64; +extern GrB_Semiring GxB_TIMES_SECOND_INT8; +extern GrB_Semiring GxB_TIMES_SECOND_INT16; +extern GrB_Semiring GxB_TIMES_SECOND_INT32; +extern GrB_Semiring GxB_TIMES_SECOND_INT64; +extern GrB_Semiring GxB_TIMES_SECOND_UINT8; +extern GrB_Semiring GxB_TIMES_SECOND_UINT16; +extern GrB_Semiring GxB_TIMES_SECOND_UINT32; +extern GrB_Semiring GxB_TIMES_SECOND_UINT64; +extern GrB_Semiring GxB_TIMES_TIMES_FP32; +extern GrB_Semiring GxB_TIMES_TIMES_FP64; +extern GrB_Semiring GxB_TIMES_TIMES_INT8; +extern GrB_Semiring GxB_TIMES_TIMES_INT16; +extern GrB_Semiring GxB_TIMES_TIMES_INT32; +extern GrB_Semiring GxB_TIMES_TIMES_INT64; +extern GrB_Semiring GxB_TIMES_TIMES_UINT8; +extern GrB_Semiring GxB_TIMES_TIMES_UINT16; +extern GrB_Semiring GxB_TIMES_TIMES_UINT32; +extern GrB_Semiring GxB_TIMES_TIMES_UINT64; +extern GrB_UnaryOp GxB_ACOSH_FP32; +extern GrB_UnaryOp GxB_ACOSH_FP64; +extern GrB_UnaryOp GxB_ACOS_FP32; +extern GrB_UnaryOp GxB_ACOS_FP64; +extern GrB_UnaryOp GxB_ASINH_FP32; +extern GrB_UnaryOp GxB_ASINH_FP64; +extern GrB_UnaryOp GxB_ASIN_FP32; +extern GrB_UnaryOp GxB_ASIN_FP64; +extern GrB_UnaryOp GxB_ATANH_FP32; +extern GrB_UnaryOp GxB_ATANH_FP64; +extern GrB_UnaryOp GxB_ATAN_FP32; +extern GrB_UnaryOp GxB_ATAN_FP64; +extern GrB_UnaryOp GxB_CBRT_FP32; +extern GrB_UnaryOp GxB_CBRT_FP64; +extern GrB_UnaryOp GxB_CEIL_FP32; +extern GrB_UnaryOp GxB_CEIL_FP64; +extern GrB_UnaryOp GxB_COSH_FP32; +extern GrB_UnaryOp GxB_COSH_FP64; +extern GrB_UnaryOp GxB_COS_FP32; +extern GrB_UnaryOp GxB_COS_FP64; +extern GrB_UnaryOp GxB_ERFC_FP32; +extern GrB_UnaryOp GxB_ERFC_FP64; +extern GrB_UnaryOp GxB_ERF_FP32; +extern GrB_UnaryOp GxB_ERF_FP64; +extern GrB_UnaryOp GxB_EXP2_FP32; +extern GrB_UnaryOp GxB_EXP2_FP64; +extern GrB_UnaryOp GxB_EXPM1_FP32; +extern GrB_UnaryOp GxB_EXPM1_FP64; +extern GrB_UnaryOp GxB_EXP_FP32; +extern GrB_UnaryOp GxB_EXP_FP64; +extern GrB_UnaryOp GxB_FLOOR_FP32; +extern GrB_UnaryOp GxB_FLOOR_FP64; +extern GrB_UnaryOp GxB_FREXPE_FP32; +extern GrB_UnaryOp GxB_FREXPE_FP64; +extern GrB_UnaryOp GxB_FREXPX_FP32; +extern GrB_UnaryOp GxB_FREXPX_FP64; +extern GrB_UnaryOp GxB_ISFINITE_FP32; +extern GrB_UnaryOp GxB_ISFINITE_FP64; +extern GrB_UnaryOp GxB_ISINF_FP32; +extern GrB_UnaryOp GxB_ISINF_FP64; +extern GrB_UnaryOp GxB_ISNAN_FP32; +extern GrB_UnaryOp GxB_ISNAN_FP64; +extern GrB_UnaryOp GxB_LGAMMA_FP32; +extern GrB_UnaryOp GxB_LGAMMA_FP64; +extern GrB_UnaryOp GxB_LNOT_BOOL; +extern GrB_UnaryOp GxB_LNOT_FP32; +extern GrB_UnaryOp GxB_LNOT_FP64; +extern GrB_UnaryOp GxB_LNOT_INT8; +extern GrB_UnaryOp GxB_LNOT_INT16; +extern GrB_UnaryOp GxB_LNOT_INT32; +extern GrB_UnaryOp GxB_LNOT_INT64; +extern GrB_UnaryOp GxB_LNOT_UINT8; +extern GrB_UnaryOp GxB_LNOT_UINT16; +extern GrB_UnaryOp GxB_LNOT_UINT32; +extern GrB_UnaryOp GxB_LNOT_UINT64; +extern GrB_UnaryOp GxB_LOG10_FP32; +extern GrB_UnaryOp GxB_LOG10_FP64; +extern GrB_UnaryOp GxB_LOG1P_FP32; +extern GrB_UnaryOp GxB_LOG1P_FP64; +extern GrB_UnaryOp GxB_LOG2_FP32; +extern GrB_UnaryOp GxB_LOG2_FP64; +extern GrB_UnaryOp GxB_LOG_FP32; +extern GrB_UnaryOp GxB_LOG_FP64; +extern GrB_UnaryOp GxB_ONE_BOOL; +extern GrB_UnaryOp GxB_ONE_FP32; +extern GrB_UnaryOp GxB_ONE_FP64; +extern GrB_UnaryOp GxB_ONE_INT8; +extern GrB_UnaryOp GxB_ONE_INT16; +extern GrB_UnaryOp GxB_ONE_INT32; +extern GrB_UnaryOp GxB_ONE_INT64; +extern GrB_UnaryOp GxB_ONE_UINT8; +extern GrB_UnaryOp GxB_ONE_UINT16; +extern GrB_UnaryOp GxB_ONE_UINT32; +extern GrB_UnaryOp GxB_ONE_UINT64; +extern GrB_UnaryOp GxB_POSITIONI1_INT32; +extern GrB_UnaryOp GxB_POSITIONI1_INT64; +extern GrB_UnaryOp GxB_POSITIONI_INT32; +extern GrB_UnaryOp GxB_POSITIONI_INT64; +extern GrB_UnaryOp GxB_POSITIONJ1_INT32; +extern GrB_UnaryOp GxB_POSITIONJ1_INT64; +extern GrB_UnaryOp GxB_POSITIONJ_INT32; +extern GrB_UnaryOp GxB_POSITIONJ_INT64; +extern GrB_UnaryOp GxB_ROUND_FP32; +extern GrB_UnaryOp GxB_ROUND_FP64; +extern GrB_UnaryOp GxB_SIGNUM_FP32; +extern GrB_UnaryOp GxB_SIGNUM_FP64; +extern GrB_UnaryOp GxB_SINH_FP32; +extern GrB_UnaryOp GxB_SINH_FP64; +extern GrB_UnaryOp GxB_SIN_FP32; +extern GrB_UnaryOp GxB_SIN_FP64; +extern GrB_UnaryOp GxB_SQRT_FP32; +extern GrB_UnaryOp GxB_SQRT_FP64; +extern GrB_UnaryOp GxB_TANH_FP32; +extern GrB_UnaryOp GxB_TANH_FP64; +extern GrB_UnaryOp GxB_TAN_FP32; +extern GrB_UnaryOp GxB_TAN_FP64; +extern GrB_UnaryOp GxB_TGAMMA_FP32; +extern GrB_UnaryOp GxB_TGAMMA_FP64; +extern GrB_UnaryOp GxB_TRUNC_FP32; +extern GrB_UnaryOp GxB_TRUNC_FP64; + +/* GxB objects */ +extern GxB_Context GxB_CONTEXT_WORLD; +extern GxB_SelectOp GxB_DIAG; +extern GxB_SelectOp GxB_EQ_THUNK; +extern GxB_SelectOp GxB_EQ_ZERO; +extern GxB_SelectOp GxB_GE_THUNK; +extern GxB_SelectOp GxB_GE_ZERO; +extern GxB_SelectOp GxB_GT_THUNK; +extern GxB_SelectOp GxB_GT_ZERO; +extern GxB_SelectOp GxB_LE_THUNK; +extern GxB_SelectOp GxB_LE_ZERO; +extern GxB_SelectOp GxB_LT_THUNK; +extern GxB_SelectOp GxB_LT_ZERO; +extern GxB_SelectOp GxB_NE_THUNK; +extern GxB_SelectOp GxB_NONZERO; +extern GxB_SelectOp GxB_OFFDIAG; +extern GxB_SelectOp GxB_TRIL; +extern GxB_SelectOp GxB_TRIU; + +/**************** +* GrB functions * +****************/ + +/* binary */ +GrB_Info GrB_BinaryOp_error(const char **error, const GrB_BinaryOp object); +GrB_Info GrB_BinaryOp_free(GrB_BinaryOp *object); +GrB_Info GrB_BinaryOp_get_INT32(GrB_BinaryOp object, int32_t *, int); +GrB_Info GrB_BinaryOp_get_SIZE(GrB_BinaryOp object, size_t *, int); +GrB_Info GrB_BinaryOp_get_String(GrB_BinaryOp object, char *, int); +GrB_Info GrB_BinaryOp_get_VOID(GrB_BinaryOp object, void *, int); +GrB_Info GrB_BinaryOp_new(GrB_BinaryOp *binaryop, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); +GrB_Info GrB_BinaryOp_set_INT32(GrB_BinaryOp object, int32_t, int); +GrB_Info GrB_BinaryOp_set_String(GrB_BinaryOp object, char *, int); +GrB_Info GrB_BinaryOp_set_VOID(GrB_BinaryOp object, void *, int, size_t); +GrB_Info GrB_BinaryOp_wait(GrB_BinaryOp object, int waitmode); + +/* core */ +GrB_Info GrB_Global_get_INT32(GrB_Global object, int32_t *, int); +GrB_Info GrB_Global_get_SIZE(GrB_Global object, size_t *, int); +GrB_Info GrB_Global_get_String(GrB_Global object, char *, int); +GrB_Info GrB_Global_get_VOID(GrB_Global object, void *, int); +GrB_Info GrB_Global_set_INT32(GrB_Global object, int32_t, int); +GrB_Info GrB_Global_set_String(GrB_Global object, char *, int); +GrB_Info GrB_Global_set_VOID(GrB_Global object, void *, int, size_t); +GrB_Info GrB_finalize(void); +GrB_Info GrB_getVersion(unsigned int *, unsigned int *); +GrB_Info GrB_init(int mode); + +/* descriptor */ +GrB_Info GrB_Descriptor_error(const char **error, const GrB_Descriptor object); +GrB_Info GrB_Descriptor_free(GrB_Descriptor *object); +GrB_Info GrB_Descriptor_get_INT32(GrB_Descriptor object, int32_t *, int); +GrB_Info GrB_Descriptor_get_SIZE(GrB_Descriptor object, size_t *, int); +GrB_Info GrB_Descriptor_get_String(GrB_Descriptor object, char *, int); +GrB_Info GrB_Descriptor_get_VOID(GrB_Descriptor object, void *, int); +GrB_Info GrB_Descriptor_new(GrB_Descriptor *descriptor); +GrB_Info GrB_Descriptor_set(GrB_Descriptor, int, int); +GrB_Info GrB_Descriptor_set_INT32(GrB_Descriptor object, int32_t, int); +GrB_Info GrB_Descriptor_set_String(GrB_Descriptor object, char *, int); +GrB_Info GrB_Descriptor_set_VOID(GrB_Descriptor object, void *, int, size_t); +GrB_Info GrB_Descriptor_wait(GrB_Descriptor object, int waitmode); + +/* indexunary */ +GrB_Info GrB_IndexUnaryOp_error(const char **error, const GrB_IndexUnaryOp object); +GrB_Info GrB_IndexUnaryOp_free(GrB_IndexUnaryOp *object); +GrB_Info GrB_IndexUnaryOp_get_INT32(GrB_IndexUnaryOp object, int32_t *, int); +GrB_Info GrB_IndexUnaryOp_get_SIZE(GrB_IndexUnaryOp object, size_t *, int); +GrB_Info GrB_IndexUnaryOp_get_String(GrB_IndexUnaryOp object, char *, int); +GrB_Info GrB_IndexUnaryOp_get_VOID(GrB_IndexUnaryOp object, void *, int); +GrB_Info GrB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); +GrB_Info GrB_IndexUnaryOp_set_INT32(GrB_IndexUnaryOp object, int32_t, int); +GrB_Info GrB_IndexUnaryOp_set_String(GrB_IndexUnaryOp object, char *, int); +GrB_Info GrB_IndexUnaryOp_set_VOID(GrB_IndexUnaryOp object, void *, int, size_t); +GrB_Info GrB_IndexUnaryOp_wait(GrB_IndexUnaryOp object, int waitmode); + +/* matrix */ +GrB_Info GrB_Col_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GrB_Col_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Scalar x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp1st_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_BinaryOp2nd_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_apply_IndexOp_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_assign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_build_BOOL(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_FP32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_FP64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT8(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT16(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_INT64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UDT(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT8(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT16(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT32(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_build_UINT64(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Matrix_clear(GrB_Matrix A); +GrB_Info GrB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size); +GrB_Info GrB_Matrix_diag(GrB_Matrix *C, const GrB_Vector v, int64_t k); +GrB_Info GrB_Matrix_dup(GrB_Matrix *C, const GrB_Matrix A); +GrB_Info GrB_Matrix_eWiseAdd_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseAdd_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseAdd_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseMult_BinaryOp(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseMult_Monoid(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_eWiseMult_Semiring(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_error(const char **error, const GrB_Matrix object); +GrB_Info GrB_Matrix_exportHint(int *format, GrB_Matrix A); +GrB_Info GrB_Matrix_exportSize(GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_BOOL(GrB_Index *Ap, GrB_Index *Ai, bool *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_FP32(GrB_Index *Ap, GrB_Index *Ai, float *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_FP64(GrB_Index *Ap, GrB_Index *Ai, double *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT8(GrB_Index *Ap, GrB_Index *Ai, int8_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT16(GrB_Index *Ap, GrB_Index *Ai, int16_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT32(GrB_Index *Ap, GrB_Index *Ai, int32_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_INT64(GrB_Index *Ap, GrB_Index *Ai, int64_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UDT(GrB_Index *Ap, GrB_Index *Ai, void *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT8(GrB_Index *Ap, GrB_Index *Ai, uint8_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT16(GrB_Index *Ap, GrB_Index *Ai, uint16_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT32(GrB_Index *Ap, GrB_Index *Ai, uint32_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_export_UINT64(GrB_Index *Ap, GrB_Index *Ai, uint64_t *Ax, GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, int format, GrB_Matrix A); +GrB_Info GrB_Matrix_extract(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_extractElement_BOOL(bool *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_FP32(float *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_FP64(double *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT8(int8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT16(int16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT32(int32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_INT64(int64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_Scalar(GrB_Scalar x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UDT(void *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT8(uint8_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT16(uint16_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT32(uint32_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractElement_UINT64(uint64_t *x, const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_extractTuples_BOOL(GrB_Index *I_, GrB_Index *J, bool *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_FP32(GrB_Index *I_, GrB_Index *J, float *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_FP64(GrB_Index *I_, GrB_Index *J, double *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT8(GrB_Index *I_, GrB_Index *J, int8_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT16(GrB_Index *I_, GrB_Index *J, int16_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT32(GrB_Index *I_, GrB_Index *J, int32_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_INT64(GrB_Index *I_, GrB_Index *J, int64_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UDT(GrB_Index *I_, GrB_Index *J, void *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT8(GrB_Index *I_, GrB_Index *J, uint8_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT16(GrB_Index *I_, GrB_Index *J, uint16_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT32(GrB_Index *I_, GrB_Index *J, uint32_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_extractTuples_UINT64(GrB_Index *I_, GrB_Index *J, uint64_t *X, GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_free(GrB_Matrix *object); +GrB_Info GrB_Matrix_get_INT32(GrB_Matrix object, int32_t *, int); +GrB_Info GrB_Matrix_get_SIZE(GrB_Matrix object, size_t *, int); +GrB_Info GrB_Matrix_get_Scalar(GrB_Matrix object, GrB_Scalar, int); +GrB_Info GrB_Matrix_get_String(GrB_Matrix object, char *, int); +GrB_Info GrB_Matrix_get_VOID(GrB_Matrix object, void *, int); +GrB_Info GrB_Matrix_import_BOOL(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const bool *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_FP32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const float *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_FP64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const double *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT8(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int8_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT16(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int16_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int32_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_INT64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const int64_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UDT(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const void *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT8(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint8_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT16(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint16_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT32(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint32_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_import_UINT64(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const GrB_Index *Ap, const GrB_Index *Ai, const uint64_t *Ax, GrB_Index Ap_len, GrB_Index Ai_len, GrB_Index Ax_len, int format); +GrB_Info GrB_Matrix_kronecker_BinaryOp(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_kronecker_Monoid(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_kronecker_Semiring(GrB_Matrix C, const GrB_Matrix M, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_ncols(GrB_Index *ncols, const GrB_Matrix A); +GrB_Info GrB_Matrix_new(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols); +GrB_Info GrB_Matrix_nrows(GrB_Index *nrows, const GrB_Matrix A); +GrB_Info GrB_Matrix_nvals(GrB_Index *nvals, const GrB_Matrix A); +GrB_Info GrB_Matrix_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_BinaryOp(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Matrix, const GrB_Descriptor); +GrB_Info GrB_Matrix_reduce_BinaryOp_Scalar(GrB_Scalar, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Matrix, const GrB_Descriptor); +GrB_Info GrB_Matrix_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_Monoid_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_removeElement(GrB_Matrix C, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_resize(GrB_Matrix C, GrB_Index nrows_new, GrB_Index ncols_new); +GrB_Info GrB_Matrix_select_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, float y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, double y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_select_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Matrix A, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Matrix_serialize(void *blob, GrB_Index *blob_size, GrB_Matrix A); +GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size, GrB_Matrix A); +GrB_Info GrB_Matrix_setElement_BOOL(GrB_Matrix C, bool x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_FP32(GrB_Matrix C, float x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_FP64(GrB_Matrix C, double x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT8(GrB_Matrix C, int8_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT16(GrB_Matrix C, int16_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT32(GrB_Matrix C, int32_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_INT64(GrB_Matrix C, int64_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_Scalar(GrB_Matrix C, GrB_Scalar x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UDT(GrB_Matrix C, void *x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT8(GrB_Matrix C, uint8_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT16(GrB_Matrix C, uint16_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT32(GrB_Matrix C, uint32_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_setElement_UINT64(GrB_Matrix C, uint64_t x, GrB_Index i, GrB_Index j); +GrB_Info GrB_Matrix_set_INT32(GrB_Matrix object, int32_t, int); +GrB_Info GrB_Matrix_set_Scalar(GrB_Matrix object, GrB_Scalar, int); +GrB_Info GrB_Matrix_set_String(GrB_Matrix object, char *, int); +GrB_Info GrB_Matrix_set_VOID(GrB_Matrix object, void *, int, size_t); +GrB_Info GrB_Matrix_wait(GrB_Matrix object, int waitmode); +GrB_Info GrB_Row_assign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GrB_mxm(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Matrix B, const GrB_Descriptor desc); +GrB_Info GrB_mxv(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Matrix A, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_transpose(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GrB_vxm(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Matrix A, const GrB_Descriptor desc); + +/* monoid */ +GrB_Info GrB_Monoid_error(const char **error, const GrB_Monoid object); +GrB_Info GrB_Monoid_free(GrB_Monoid *object); +GrB_Info GrB_Monoid_get_INT32(GrB_Monoid object, int32_t *, int); +GrB_Info GrB_Monoid_get_SIZE(GrB_Monoid object, size_t *, int); +GrB_Info GrB_Monoid_get_String(GrB_Monoid object, char *, int); +GrB_Info GrB_Monoid_get_VOID(GrB_Monoid object, void *, int); +GrB_Info GrB_Monoid_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity); +GrB_Info GrB_Monoid_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity); +GrB_Info GrB_Monoid_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity); +GrB_Info GrB_Monoid_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity); +GrB_Info GrB_Monoid_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity); +GrB_Info GrB_Monoid_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity); +GrB_Info GrB_Monoid_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity); +GrB_Info GrB_Monoid_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity); +GrB_Info GrB_Monoid_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity); +GrB_Info GrB_Monoid_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity); +GrB_Info GrB_Monoid_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity); +GrB_Info GrB_Monoid_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity); +GrB_Info GrB_Monoid_set_INT32(GrB_Monoid object, int32_t, int); +GrB_Info GrB_Monoid_set_String(GrB_Monoid object, char *, int); +GrB_Info GrB_Monoid_set_VOID(GrB_Monoid object, void *, int, size_t); +GrB_Info GrB_Monoid_wait(GrB_Monoid object, int waitmode); + +/* scalar */ +GrB_Info GrB_BinaryOp_get_Scalar(GrB_BinaryOp object, GrB_Scalar, int); +GrB_Info GrB_BinaryOp_set_Scalar(GrB_BinaryOp object, GrB_Scalar, int); +GrB_Info GrB_Descriptor_get_Scalar(GrB_Descriptor object, GrB_Scalar, int); +GrB_Info GrB_Descriptor_set_Scalar(GrB_Descriptor object, GrB_Scalar, int); +GrB_Info GrB_Global_get_Scalar(GrB_Global object, GrB_Scalar, int); +GrB_Info GrB_Global_set_Scalar(GrB_Global object, GrB_Scalar, int); +GrB_Info GrB_IndexUnaryOp_get_Scalar(GrB_IndexUnaryOp object, GrB_Scalar, int); +GrB_Info GrB_IndexUnaryOp_set_Scalar(GrB_IndexUnaryOp object, GrB_Scalar, int); +GrB_Info GrB_Monoid_get_Scalar(GrB_Monoid object, GrB_Scalar, int); +GrB_Info GrB_Monoid_set_Scalar(GrB_Monoid object, GrB_Scalar, int); +GrB_Info GrB_Scalar_clear(GrB_Scalar s); +GrB_Info GrB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); +GrB_Info GrB_Scalar_error(const char **error, const GrB_Scalar object); +GrB_Info GrB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); +GrB_Info GrB_Scalar_free(GrB_Scalar *object); +GrB_Info GrB_Scalar_get_INT32(GrB_Scalar object, int32_t *, int); +GrB_Info GrB_Scalar_get_SIZE(GrB_Scalar object, size_t *, int); +GrB_Info GrB_Scalar_get_Scalar(GrB_Scalar object, GrB_Scalar, int); +GrB_Info GrB_Scalar_get_String(GrB_Scalar object, char *, int); +GrB_Info GrB_Scalar_get_VOID(GrB_Scalar object, void *, int); +GrB_Info GrB_Scalar_new(GrB_Scalar *s, GrB_Type type); +GrB_Info GrB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); +GrB_Info GrB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); +GrB_Info GrB_Scalar_setElement_FP32(GrB_Scalar s, float x); +GrB_Info GrB_Scalar_setElement_FP64(GrB_Scalar s, double x); +GrB_Info GrB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); +GrB_Info GrB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); +GrB_Info GrB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); +GrB_Info GrB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); +GrB_Info GrB_Scalar_setElement_UDT(GrB_Scalar s, void *x); +GrB_Info GrB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); +GrB_Info GrB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); +GrB_Info GrB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); +GrB_Info GrB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); +GrB_Info GrB_Scalar_set_INT32(GrB_Scalar object, int32_t, int); +GrB_Info GrB_Scalar_set_Scalar(GrB_Scalar object, GrB_Scalar, int); +GrB_Info GrB_Scalar_set_String(GrB_Scalar object, char *, int); +GrB_Info GrB_Scalar_set_VOID(GrB_Scalar object, void *, int, size_t); +GrB_Info GrB_Scalar_wait(GrB_Scalar object, int waitmode); +GrB_Info GrB_Semiring_get_Scalar(GrB_Semiring object, GrB_Scalar, int); +GrB_Info GrB_Semiring_set_Scalar(GrB_Semiring object, GrB_Scalar, int); +GrB_Info GrB_Type_get_Scalar(GrB_Type object, GrB_Scalar, int); +GrB_Info GrB_Type_set_Scalar(GrB_Type object, GrB_Scalar, int); +GrB_Info GrB_UnaryOp_get_Scalar(GrB_UnaryOp object, GrB_Scalar, int); +GrB_Info GrB_UnaryOp_set_Scalar(GrB_UnaryOp object, GrB_Scalar, int); + +/* semiring */ +GrB_Info GrB_Semiring_error(const char **error, const GrB_Semiring object); +GrB_Info GrB_Semiring_free(GrB_Semiring *object); +GrB_Info GrB_Semiring_get_INT32(GrB_Semiring object, int32_t *, int); +GrB_Info GrB_Semiring_get_SIZE(GrB_Semiring object, size_t *, int); +GrB_Info GrB_Semiring_get_String(GrB_Semiring object, char *, int); +GrB_Info GrB_Semiring_get_VOID(GrB_Semiring object, void *, int); +GrB_Info GrB_Semiring_new(GrB_Semiring *semiring, GrB_Monoid add, GrB_BinaryOp multiply); +GrB_Info GrB_Semiring_set_INT32(GrB_Semiring object, int32_t, int); +GrB_Info GrB_Semiring_set_String(GrB_Semiring object, char *, int); +GrB_Info GrB_Semiring_set_VOID(GrB_Semiring object, void *, int, size_t); +GrB_Info GrB_Semiring_wait(GrB_Semiring object, int waitmode); + +/* type */ +GrB_Info GrB_Type_error(const char **error, const GrB_Type object); +GrB_Info GrB_Type_free(GrB_Type *object); +GrB_Info GrB_Type_get_INT32(GrB_Type object, int32_t *, int); +GrB_Info GrB_Type_get_SIZE(GrB_Type object, size_t *, int); +GrB_Info GrB_Type_get_String(GrB_Type object, char *, int); +GrB_Info GrB_Type_get_VOID(GrB_Type object, void *, int); +GrB_Info GrB_Type_new(GrB_Type *type, size_t sizeof_ctype); +GrB_Info GrB_Type_set_INT32(GrB_Type object, int32_t, int); +GrB_Info GrB_Type_set_String(GrB_Type object, char *, int); +GrB_Info GrB_Type_set_VOID(GrB_Type object, void *, int, size_t); +GrB_Info GrB_Type_wait(GrB_Type object, int waitmode); + +/* unary */ +GrB_Info GrB_UnaryOp_error(const char **error, const GrB_UnaryOp object); +GrB_Info GrB_UnaryOp_free(GrB_UnaryOp *object); +GrB_Info GrB_UnaryOp_get_INT32(GrB_UnaryOp object, int32_t *, int); +GrB_Info GrB_UnaryOp_get_SIZE(GrB_UnaryOp object, size_t *, int); +GrB_Info GrB_UnaryOp_get_String(GrB_UnaryOp object, char *, int); +GrB_Info GrB_UnaryOp_get_VOID(GrB_UnaryOp object, void *, int); +GrB_Info GrB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype); +GrB_Info GrB_UnaryOp_set_INT32(GrB_UnaryOp object, int32_t, int); +GrB_Info GrB_UnaryOp_set_String(GrB_UnaryOp object, char *, int); +GrB_Info GrB_UnaryOp_set_VOID(GrB_UnaryOp object, void *, int, size_t); +GrB_Info GrB_UnaryOp_wait(GrB_UnaryOp object, int waitmode); + +/* vector */ +GrB_Info GrB_Vector_apply(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_UnaryOp op, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, bool x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, float x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, double x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int8_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int16_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int32_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, int64_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Scalar x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const void *x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint8_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint16_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint32_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp1st_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, uint64_t x, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_BinaryOp2nd_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_apply_IndexOp_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_assign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_build_BOOL(GrB_Vector w, const GrB_Index *I_, const bool *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_FP32(GrB_Vector w, const GrB_Index *I_, const float *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_FP64(GrB_Vector w, const GrB_Index *I_, const double *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT8(GrB_Vector w, const GrB_Index *I_, const int8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT16(GrB_Vector w, const GrB_Index *I_, const int16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT32(GrB_Vector w, const GrB_Index *I_, const int32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_INT64(GrB_Vector w, const GrB_Index *I_, const int64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UDT(GrB_Vector w, const GrB_Index *I_, const void *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT8(GrB_Vector w, const GrB_Index *I_, const uint8_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT16(GrB_Vector w, const GrB_Index *I_, const uint16_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT32(GrB_Vector w, const GrB_Index *I_, const uint32_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_build_UINT64(GrB_Vector w, const GrB_Index *I_, const uint64_t *X, GrB_Index nvals, const GrB_BinaryOp dup); +GrB_Info GrB_Vector_clear(GrB_Vector v); +GrB_Info GrB_Vector_dup(GrB_Vector *w, const GrB_Vector u); +GrB_Info GrB_Vector_eWiseAdd_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseAdd_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseAdd_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseMult_BinaryOp(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp mult, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseMult_Monoid(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_eWiseMult_Semiring(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Semiring semiring, const GrB_Vector u, const GrB_Vector v, const GrB_Descriptor desc); +GrB_Info GrB_Vector_error(const char **error, const GrB_Vector object); +GrB_Info GrB_Vector_extract(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GrB_Vector_extractElement_BOOL(bool *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_FP32(float *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_FP64(double *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT8(int8_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT16(int16_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT32(int32_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_INT64(int64_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_Scalar(GrB_Scalar x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UDT(void *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT8(uint8_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT16(uint16_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT32(uint32_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractElement_UINT64(uint64_t *x, const GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_extractTuples_BOOL(GrB_Index *I_, bool *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_FP32(GrB_Index *I_, float *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_FP64(GrB_Index *I_, double *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT8(GrB_Index *I_, int8_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT16(GrB_Index *I_, int16_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT32(GrB_Index *I_, int32_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_INT64(GrB_Index *I_, int64_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UDT(GrB_Index *I_, void *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT8(GrB_Index *I_, uint8_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT16(GrB_Index *I_, uint16_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT32(GrB_Index *I_, uint32_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_extractTuples_UINT64(GrB_Index *I_, uint64_t *X, GrB_Index *nvals, const GrB_Vector V); +GrB_Info GrB_Vector_free(GrB_Vector *object); +GrB_Info GrB_Vector_get_INT32(GrB_Vector object, int32_t *, int); +GrB_Info GrB_Vector_get_SIZE(GrB_Vector object, size_t *, int); +GrB_Info GrB_Vector_get_Scalar(GrB_Vector object, GrB_Scalar, int); +GrB_Info GrB_Vector_get_String(GrB_Vector object, char *, int); +GrB_Info GrB_Vector_get_VOID(GrB_Vector object, void *, int); +GrB_Info GrB_Vector_new(GrB_Vector *v, GrB_Type type, GrB_Index n); +GrB_Info GrB_Vector_nvals(GrB_Index *nvals, const GrB_Vector v); +GrB_Info GrB_Vector_reduce_BOOL(bool *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_BinaryOp_Scalar(GrB_Scalar, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Vector, const GrB_Descriptor); +GrB_Info GrB_Vector_reduce_FP32(float *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_FP64(double *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT8(int8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT16(int16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT32(int32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_INT64(int64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_Monoid_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UDT(void *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT8(uint8_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT16(uint16_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT32(uint32_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_reduce_UINT64(uint64_t *c, const GrB_BinaryOp accum, const GrB_Monoid monoid, const GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GrB_Vector_removeElement(GrB_Vector v, GrB_Index i); +GrB_Info GrB_Vector_resize(GrB_Vector w, GrB_Index nrows_new); +GrB_Info GrB_Vector_select_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, bool y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, float y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, double y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, int64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const GrB_Scalar y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, const void *y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint8_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint16_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint32_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_select_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_IndexUnaryOp op, const GrB_Vector u, uint64_t y, const GrB_Descriptor desc); +GrB_Info GrB_Vector_setElement_BOOL(GrB_Vector w, bool x, GrB_Index i); +GrB_Info GrB_Vector_setElement_FP32(GrB_Vector w, float x, GrB_Index i); +GrB_Info GrB_Vector_setElement_FP64(GrB_Vector w, double x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT8(GrB_Vector w, int8_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT16(GrB_Vector w, int16_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT32(GrB_Vector w, int32_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_INT64(GrB_Vector w, int64_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_Scalar(GrB_Vector w, GrB_Scalar x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UDT(GrB_Vector w, void *x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT8(GrB_Vector w, uint8_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT16(GrB_Vector w, uint16_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT32(GrB_Vector w, uint32_t x, GrB_Index i); +GrB_Info GrB_Vector_setElement_UINT64(GrB_Vector w, uint64_t x, GrB_Index i); +GrB_Info GrB_Vector_set_INT32(GrB_Vector object, int32_t, int); +GrB_Info GrB_Vector_set_Scalar(GrB_Vector object, GrB_Scalar, int); +GrB_Info GrB_Vector_set_String(GrB_Vector object, char *, int); +GrB_Info GrB_Vector_set_VOID(GrB_Vector object, void *, int, size_t); +GrB_Info GrB_Vector_size(GrB_Index *n, const GrB_Vector v); +GrB_Info GrB_Vector_wait(GrB_Vector object, int waitmode); + +/*************** +* GB functions * +***************/ + +/* iterator */ +GrB_Info GB_Iterator_rc_bitmap_next(GxB_Iterator iterator); +GrB_Info GB_Iterator_rc_seek(GxB_Iterator iterator, GrB_Index j, bool jth_vector); +GrB_Info GB_Vector_Iterator_bitmap_seek(GxB_Iterator iterator); + +/* matrix */ +GrB_Info GB_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, int format, GrB_Descriptor desc); + +/**************** +* GxB functions * +****************/ + +/* binary */ +GrB_Info GxB_BinaryOp_fprint(GrB_BinaryOp binaryop, const char *name, int pr, FILE *f); +GrB_Info GxB_BinaryOp_new(GrB_BinaryOp *op, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *binop_name, const char *binop_defn); +GrB_Info GxB_BinaryOp_new_arena(GrB_BinaryOp *op_handle, GxB_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *binop_name, const char *binop_defn, const int header_arena); +GrB_Info GxB_BinaryOp_xtype(GrB_Type *, GrB_BinaryOp); +GrB_Info GxB_BinaryOp_xtype_name(char *, const GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ytype(GrB_Type *, GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ytype_name(char *, const GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ztype(GrB_Type *, GrB_BinaryOp); +GrB_Info GxB_BinaryOp_ztype_name(char *, const GrB_BinaryOp); + +/* container */ +GrB_Info GxB_Container_free(GxB_Container *object); +GrB_Info GxB_Container_new(GxB_Container *Container); +GrB_Info GxB_Container_new_arena(GxB_Container *Container, const int header_arena, const int data_arena); + +/* context */ +GrB_Info GxB_Context_disengage(GxB_Context Context); +GrB_Info GxB_Context_engage(GxB_Context Context); +GrB_Info GxB_Context_error(const char **error, const GxB_Context object); +GrB_Info GxB_Context_fprint(GxB_Context Context, const char *name, int pr, FILE *f); +GrB_Info GxB_Context_free(GxB_Context *object); +GrB_Info GxB_Context_get(GxB_Context, int, ...); +GrB_Info GxB_Context_get_FP64(GxB_Context, int, double *); +GrB_Info GxB_Context_get_INT(GxB_Context, int32_t *, int); +GrB_Info GxB_Context_get_INT32(GxB_Context, int, int32_t *); +GrB_Info GxB_Context_get_SIZE(GxB_Context, size_t *, int); +GrB_Info GxB_Context_get_String(GxB_Context, char *, int); +GrB_Info GxB_Context_get_VOID(GxB_Context, void *, int); +GrB_Info GxB_Context_new(GxB_Context *Context); +GrB_Info GxB_Context_new_arena(GxB_Context *Context_handle, const int header_arena); +GrB_Info GxB_Context_set(GxB_Context, int, ...); +GrB_Info GxB_Context_set_FP64(GxB_Context, int, double); +GrB_Info GxB_Context_set_INT(GxB_Context, int32_t, int); +GrB_Info GxB_Context_set_INT32(GxB_Context, int, int32_t); +GrB_Info GxB_Context_set_String(GxB_Context, char *, int); +GrB_Info GxB_Context_set_VOID(GxB_Context, void *, int, size_t); +GrB_Info GxB_Context_wait(GxB_Context object, int waitmode); + +/* core */ +GrB_Info GxB_Global_Option_get(int, ...); +GrB_Info GxB_Global_Option_get_CHAR(int, const char **); +GrB_Info GxB_Global_Option_get_FP64(int, double *); +GrB_Info GxB_Global_Option_get_FUNCTION(int, void **); +GrB_Info GxB_Global_Option_get_INT32(int, int32_t *); +GrB_Info GxB_Global_Option_get_INT64(int, int64_t *); +GrB_Info GxB_Global_Option_set(int, ...); +GrB_Info GxB_Global_Option_set_CHAR(int, const char *); +GrB_Info GxB_Global_Option_set_FP64(int, double); +GrB_Info GxB_Global_Option_set_FP64_ARRAY(int, double *); +GrB_Info GxB_Global_Option_set_FUNCTION(int, void *); +GrB_Info GxB_Global_Option_set_INT32(int, int32_t); +GrB_Info GxB_Global_Option_set_INT64_ARRAY(int, int64_t *); +GrB_Info GxB_Serialized_get_INT32(const void *, int32_t *, int, size_t); +GrB_Info GxB_Serialized_get_SIZE(const void *, size_t *, int, size_t); +GrB_Info GxB_Serialized_get_String(const void *, char *, int, size_t); +GrB_Info GxB_Serialized_get_VOID(const void *, void *, int, size_t); +GrB_Info GxB_arena_init(int arena, void *(*user_malloc_function)(size_t), void *(*user_calloc_function)(size_t, size_t), void *(*user_realloc_function)(void *, size_t), void (*user_free_function)(void *)); +GrB_Info GxB_arena_initialized(int *flag, int arena); +GrB_Info GxB_deserialize_type_name(char *, const void *, uint64_t); +GrB_Info GxB_finalized(int *flag); +GrB_Info GxB_init(int mode, void *(*user_malloc_function)(size_t), void *(*user_calloc_function)(size_t, size_t), void *(*user_realloc_function)(void *, size_t), void (*user_free_function)(void *)); +GrB_Info GxB_initialized(int *flag); +void GxB_atfork_child(void); +void GxB_atfork_parent(void); +void GxB_atfork_prepare(void); + +/* descriptor */ +GrB_Info GxB_Desc_get(GrB_Descriptor, int, ...); +GrB_Info GxB_Desc_get_FP64(GrB_Descriptor, int, double *); +GrB_Info GxB_Desc_get_INT32(GrB_Descriptor, int, int32_t *); +GrB_Info GxB_Desc_set(GrB_Descriptor, int, ...); +GrB_Info GxB_Desc_set_FP64(GrB_Descriptor, int, double); +GrB_Info GxB_Desc_set_INT32(GrB_Descriptor, int, int32_t); +GrB_Info GxB_Descriptor_fprint(GrB_Descriptor descriptor, const char *name, int pr, FILE *f); +GrB_Info GxB_Descriptor_get(int32_t *, GrB_Descriptor, int); +GrB_Info GxB_Descriptor_new_arena(GrB_Descriptor *descriptor, const int header_arena); + +/* indexbinary */ +GrB_Info GxB_IndexBinaryOp_error(const char **error, const GxB_IndexBinaryOp object); +GrB_Info GxB_IndexBinaryOp_fprint(GxB_IndexBinaryOp op, const char *name, int pr, FILE *f); +GrB_Info GxB_IndexBinaryOp_free(GxB_IndexBinaryOp *object); +GrB_Info GxB_IndexBinaryOp_get_INT32(GxB_IndexBinaryOp object, int32_t *, int); +GrB_Info GxB_IndexBinaryOp_get_SIZE(GxB_IndexBinaryOp object, size_t *, int); +GrB_Info GxB_IndexBinaryOp_get_String(GxB_IndexBinaryOp object, char *, int); +GrB_Info GxB_IndexBinaryOp_get_VOID(GxB_IndexBinaryOp object, void *, int); +GrB_Info GxB_IndexBinaryOp_new(GxB_IndexBinaryOp *op, GxB_index_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, GrB_Type theta_type, const char *idxbinop_name, const char *idxbinop_defn); +GrB_Info GxB_IndexBinaryOp_new_arena(GxB_IndexBinaryOp *op_handle, GxB_index_binary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, GrB_Type theta_type, const char *idxop_name, const char *idxop_defn, const int header_arena); +GrB_Info GxB_IndexBinaryOp_set_INT32(GxB_IndexBinaryOp object, int32_t, int); +GrB_Info GxB_IndexBinaryOp_set_String(GxB_IndexBinaryOp object, char *, int); +GrB_Info GxB_IndexBinaryOp_set_VOID(GxB_IndexBinaryOp object, void *, int, size_t); +GrB_Info GxB_IndexBinaryOp_wait(GxB_IndexBinaryOp object, int waitmode); + +/* indexunary */ +GrB_Info GxB_IndexUnaryOp_fprint(GrB_IndexUnaryOp op, const char *name, int pr, FILE *f); +GrB_Info GxB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *idxop_name, const char *idxop_defn); +GrB_Info GxB_IndexUnaryOp_new_arena(GrB_IndexUnaryOp *op_handle, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype, const char *idxop_name, const char *idxop_defn, const int header_arena); +GrB_Info GxB_IndexUnaryOp_xtype_name(char *, const GrB_IndexUnaryOp); +GrB_Info GxB_IndexUnaryOp_ytype_name(char *, const GrB_IndexUnaryOp); +GrB_Info GxB_IndexUnaryOp_ztype_name(char *, const GrB_IndexUnaryOp); + +/* iterator */ +GrB_Index GxB_Matrix_Iterator_getp(GxB_Iterator iterator); +GrB_Index GxB_Matrix_Iterator_getpmax(GxB_Iterator iterator); +GrB_Index GxB_Vector_Iterator_getIndex(GxB_Iterator iterator); +GrB_Index GxB_Vector_Iterator_getp(GxB_Iterator iterator); +GrB_Index GxB_Vector_Iterator_getpmax(GxB_Iterator iterator); +GrB_Index GxB_colIterator_getColIndex(GxB_Iterator iterator); +GrB_Index GxB_colIterator_getRowIndex(GxB_Iterator iterator); +GrB_Index GxB_colIterator_kount(GxB_Iterator iterator); +GrB_Index GxB_rowIterator_getColIndex(GxB_Iterator iterator); +GrB_Index GxB_rowIterator_getRowIndex(GxB_Iterator iterator); +GrB_Index GxB_rowIterator_kount(GxB_Iterator iterator); +GrB_Info GxB_Iterator_free(GxB_Iterator *object); +GrB_Info GxB_Iterator_new(GxB_Iterator *iterator); +GrB_Info GxB_Iterator_new_arena(GxB_Iterator *iterator, const int header_arena); +GrB_Info GxB_Matrix_Iterator_next(GxB_Iterator iterator); +GrB_Info GxB_Matrix_Iterator_seek(GxB_Iterator iterator, GrB_Index p); +GrB_Info GxB_Vector_Iterator_next(GxB_Iterator iterator); +GrB_Info GxB_Vector_Iterator_seek(GxB_Iterator iterator, GrB_Index p); +GrB_Info GxB_colIterator_kseek(GxB_Iterator iterator, GrB_Index k); +GrB_Info GxB_colIterator_nextCol(GxB_Iterator iterator); +GrB_Info GxB_colIterator_nextRow(GxB_Iterator iterator); +GrB_Info GxB_colIterator_seekCol(GxB_Iterator iterator, GrB_Index col); +GrB_Info GxB_rowIterator_kseek(GxB_Iterator iterator, GrB_Index k); +GrB_Info GxB_rowIterator_nextCol(GxB_Iterator iterator); +GrB_Info GxB_rowIterator_nextRow(GxB_Iterator iterator); +GrB_Info GxB_rowIterator_seekRow(GxB_Iterator iterator, GrB_Index row); +bool GxB_Iterator_get_BOOL(GxB_Iterator iterator); +double GxB_Iterator_get_FP64(GxB_Iterator iterator); +float GxB_Iterator_get_FP32(GxB_Iterator iterator); +int8_t GxB_Iterator_get_INT8(GxB_Iterator iterator); +int16_t GxB_Iterator_get_INT16(GxB_Iterator iterator); +int32_t GxB_Iterator_get_INT32(GxB_Iterator iterator); +int64_t GxB_Iterator_get_INT64(GxB_Iterator iterator); +uint8_t GxB_Iterator_get_UINT8(GxB_Iterator iterator); +uint16_t GxB_Iterator_get_UINT16(GxB_Iterator iterator); +uint32_t GxB_Iterator_get_UINT32(GxB_Iterator iterator); +uint64_t GxB_Iterator_get_UINT64(GxB_Iterator iterator); +void GxB_Iterator_get_UDT(GxB_Iterator iterator, void *value); +void GxB_Matrix_Iterator_getIndex(GxB_Iterator iterator, GrB_Index *row, GrB_Index *col); + +/* matrix */ +GrB_Info GxB_Col_assign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Col_extract_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Col_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Col_subassign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, GrB_Index j, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); +GrB_Info GxB_Matrix_Option_get(GrB_Matrix, int, ...); +GrB_Info GxB_Matrix_Option_get_FP64(GrB_Matrix, int, double *); +GrB_Info GxB_Matrix_Option_get_INT32(GrB_Matrix, int, int32_t *); +GrB_Info GxB_Matrix_Option_set(GrB_Matrix, int, ...); +GrB_Info GxB_Matrix_Option_set_FP64(GrB_Matrix, int, double); +GrB_Info GxB_Matrix_Option_set_INT32(GrB_Matrix, int, int32_t); +GrB_Info GxB_Matrix_apply_BinaryOp1st(GrB_Matrix, const GrB_Matrix, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Scalar, const GrB_Matrix, const GrB_Descriptor); +GrB_Info GxB_Matrix_apply_BinaryOp2nd(GrB_Matrix, const GrB_Matrix, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Matrix, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Matrix_assign_Scalar_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_assign_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_build_Scalar(GrB_Matrix C, const GrB_Index *I_, const GrB_Index *J, GrB_Scalar scalar, GrB_Index nvals); +GrB_Info GxB_Matrix_build_Scalar_Vector(GrB_Matrix C, const GrB_Vector I_vector, const GrB_Vector J_vector, GrB_Scalar scalar, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_build_Vector(GrB_Matrix C, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Vector X_vector, const GrB_BinaryOp dup, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_concat(GrB_Matrix C, const GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_deserialize_arena(GrB_Matrix *C, GrB_Type type, const void *blob, uint64_t blob_memsize, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_diag_arena(GrB_Matrix *C, const GrB_Vector v, int64_t k, const int header_arena, const int data_arena); +GrB_Info GxB_Matrix_dup_arena(GrB_Matrix *C, const GrB_Matrix A, const int header_arena, const int data_arena); +GrB_Info GxB_Matrix_eWiseUnion(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Matrix A, const GrB_Scalar alpha, const GrB_Matrix B, const GrB_Scalar beta, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_export_BitmapC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_BitmapR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_CSC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_CSR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_FullC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_FullR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_HyperCSC(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_export_HyperCSR(GrB_Matrix *, GrB_Type *, uint64_t *, uint64_t *, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_extractTuples_Vector(GrB_Vector I_vector, GrB_Vector J_vector, GrB_Vector X_vector, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_extract_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_fprint(GrB_Matrix A, const char *name, int pr, FILE *f); +GrB_Info GxB_Matrix_import_BitmapC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_BitmapR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_CSC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_CSR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_FullC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_FullR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_HyperCSC(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_import_HyperCSR(GrB_Matrix *, GrB_Type, uint64_t, uint64_t, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_isStoredElement(const GrB_Matrix A, GrB_Index i, GrB_Index j); +GrB_Info GxB_Matrix_iso(bool *, const GrB_Matrix); +GrB_Info GxB_Matrix_memoryUsage(size_t *size, const GrB_Matrix A); +GrB_Info GxB_Matrix_new_arena(GrB_Matrix *A, GrB_Type type, GrB_Index nrows, GrB_Index ncols, const int header_arena, const int data_arena); +GrB_Info GxB_Matrix_pack_BitmapC(GrB_Matrix, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_BitmapR(GrB_Matrix, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_CSC(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_CSR(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, bool, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_FullC(GrB_Matrix, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_FullR(GrB_Matrix, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_HyperCSC(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_pack_HyperCSR(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t, uint64_t, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Matrix_reshape(GrB_Matrix C, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_reshapeDup(GrB_Matrix *C, GrB_Matrix A, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_reshapeDup_arena(GrB_Matrix *C, GrB_Matrix A, bool by_col, uint64_t nrows_new, uint64_t ncols_new, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_select(GrB_Matrix, const GrB_Matrix, const GrB_BinaryOp, const GxB_SelectOp, const GrB_Matrix, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Matrix_serialize(void **blob_handle, GrB_Index *blob_size, GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_serialize_arena(void **blob_handle, GrB_Index *blob_size, GrB_Matrix A, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_set_arenas(GrB_Matrix *Ahandle, const int new_header_arena, const int new_data_arena); +GrB_Info GxB_Matrix_sort(GrB_Matrix C, GrB_Matrix P, GrB_BinaryOp op, GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_split(GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Index *Tile_nrows, const GrB_Index *Tile_ncols, const GrB_Matrix A, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_split_arena(GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Index *Tile_nrows, const GrB_Index *Tile_ncols, const GrB_Matrix A, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_BOOL(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_FP32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_FP64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_INT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_Scalar_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Scalar scalar, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UDT(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT8(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT16(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT32(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_UINT64(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_subassign_Vector(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, const GrB_Matrix A, const GrB_Vector I_vector, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Matrix_type(GrB_Type *type, const GrB_Matrix A); +GrB_Info GxB_Matrix_type_name(char *, const GrB_Matrix); +GrB_Info GxB_Matrix_unpack_BitmapC(GrB_Matrix, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_BitmapR(GrB_Matrix, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_CSC(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_CSR(GrB_Matrix, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, bool *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_FullC(GrB_Matrix, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_FullR(GrB_Matrix, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_HyperCSC(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Matrix_unpack_HyperCSR(GrB_Matrix, uint64_t **, uint64_t **, uint64_t **, void **, uint64_t *, uint64_t *, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Row_assign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Row_subassign(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Index *J, GrB_Index nj, const GrB_Descriptor desc); +GrB_Info GxB_Row_subassign_Vector(GrB_Matrix C, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, GrB_Index i, const GrB_Vector J_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_diag(GrB_Vector v, const GrB_Matrix A, int64_t k, const GrB_Descriptor desc); +GrB_Info GxB_colIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); +GrB_Info GxB_load_Matrix_from_Container(GrB_Matrix A, GxB_Container Container, const GrB_Descriptor desc); +GrB_Info GxB_pack_HyperHash(GrB_Matrix, GrB_Matrix *, const GrB_Descriptor); +GrB_Info GxB_rowIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); +GrB_Info GxB_unload_Matrix_into_Container(GrB_Matrix A, GxB_Container Container, const GrB_Descriptor desc); +GrB_Info GxB_unpack_HyperHash(GrB_Matrix, GrB_Matrix *, const GrB_Descriptor); + +/* monoid */ +GrB_Info GxB_Monoid_fprint(GrB_Monoid monoid, const char *name, int pr, FILE *f); +GrB_Info GxB_Monoid_identity(void *, GrB_Monoid); +GrB_Info GxB_Monoid_new_arena_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, const int header_arena); +GrB_Info GxB_Monoid_new_arena_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, const int header_arena); +GrB_Info GxB_Monoid_operator(GrB_BinaryOp *, GrB_Monoid); +GrB_Info GxB_Monoid_terminal(bool *, void *, GrB_Monoid); +GrB_Info GxB_Monoid_terminal_new_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, bool terminal); +GrB_Info GxB_Monoid_terminal_new_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, float terminal); +GrB_Info GxB_Monoid_terminal_new_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, double terminal); +GrB_Info GxB_Monoid_terminal_new_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, int8_t terminal); +GrB_Info GxB_Monoid_terminal_new_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, int16_t terminal); +GrB_Info GxB_Monoid_terminal_new_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, int32_t terminal); +GrB_Info GxB_Monoid_terminal_new_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, int64_t terminal); +GrB_Info GxB_Monoid_terminal_new_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, void *terminal); +GrB_Info GxB_Monoid_terminal_new_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, uint8_t terminal); +GrB_Info GxB_Monoid_terminal_new_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, uint16_t terminal); +GrB_Info GxB_Monoid_terminal_new_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, uint32_t terminal); +GrB_Info GxB_Monoid_terminal_new_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, uint64_t terminal); +GrB_Info GxB_Monoid_terminal_new_arena_BOOL(GrB_Monoid *monoid, GrB_BinaryOp op, bool identity, bool terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_FP32(GrB_Monoid *monoid, GrB_BinaryOp op, float identity, float terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_FP64(GrB_Monoid *monoid, GrB_BinaryOp op, double identity, double terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT8(GrB_Monoid *monoid, GrB_BinaryOp op, int8_t identity, int8_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT16(GrB_Monoid *monoid, GrB_BinaryOp op, int16_t identity, int16_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT32(GrB_Monoid *monoid, GrB_BinaryOp op, int32_t identity, int32_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_INT64(GrB_Monoid *monoid, GrB_BinaryOp op, int64_t identity, int64_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UDT(GrB_Monoid *monoid, GrB_BinaryOp op, void *identity, void *terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT8(GrB_Monoid *monoid, GrB_BinaryOp op, uint8_t identity, uint8_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT16(GrB_Monoid *monoid, GrB_BinaryOp op, uint16_t identity, uint16_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT32(GrB_Monoid *monoid, GrB_BinaryOp op, uint32_t identity, uint32_t terminal, const int header_arena); +GrB_Info GxB_Monoid_terminal_new_arena_UINT64(GrB_Monoid *monoid, GrB_BinaryOp op, uint64_t identity, uint64_t terminal, const int header_arena); + +/* scalar */ +GrB_Info GxB_BinaryOp_new_IndexOp(GrB_BinaryOp *binop, GxB_IndexBinaryOp idxbinop, GrB_Scalar theta); +GrB_Info GxB_BinaryOp_new_IndexOp_arena(GrB_BinaryOp *binop_handle, GxB_IndexBinaryOp idxbinop, GrB_Scalar theta, const int header_arena); +GrB_Info GxB_Context_get_Scalar(GxB_Context, GrB_Scalar, int); +GrB_Info GxB_Context_set_Scalar(GxB_Context, GrB_Scalar, int); +GrB_Info GxB_IndexBinaryOp_get_Scalar(GxB_IndexBinaryOp object, GrB_Scalar, int); +GrB_Info GxB_IndexBinaryOp_set_Scalar(GxB_IndexBinaryOp object, GrB_Scalar, int); +GrB_Info GxB_Scalar_clear(GrB_Scalar); +GrB_Info GxB_Scalar_dup(GrB_Scalar *, const GrB_Scalar); +GrB_Info GxB_Scalar_dup_arena(GrB_Scalar *s, const GrB_Scalar t, const int header_arena, const int data_arena); +GrB_Info GxB_Scalar_error(const char **, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_BOOL(bool *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_FP32(float *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_FP64(double *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT8(int8_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT16(int16_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT32(int32_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_INT64(int64_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UDT(void *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_fprint(GrB_Scalar s, const char *name, int pr, FILE *f); +GrB_Info GxB_Scalar_free(GrB_Scalar *); +GrB_Info GxB_Scalar_memoryUsage(size_t *size, const GrB_Scalar s); +GrB_Info GxB_Scalar_new(GrB_Scalar *, GrB_Type); +GrB_Info GxB_Scalar_new_arena(GrB_Scalar *s, GrB_Type type, const int header_arena, const int data_arena); +GrB_Info GxB_Scalar_nvals(uint64_t *, const GrB_Scalar); +GrB_Info GxB_Scalar_setElement_BOOL(GrB_Scalar, bool); +GrB_Info GxB_Scalar_setElement_FP32(GrB_Scalar, float); +GrB_Info GxB_Scalar_setElement_FP64(GrB_Scalar, double); +GrB_Info GxB_Scalar_setElement_INT8(GrB_Scalar, int8_t); +GrB_Info GxB_Scalar_setElement_INT16(GrB_Scalar, int16_t); +GrB_Info GxB_Scalar_setElement_INT32(GrB_Scalar, int32_t); +GrB_Info GxB_Scalar_setElement_INT64(GrB_Scalar, int64_t); +GrB_Info GxB_Scalar_setElement_UDT(GrB_Scalar, void *); +GrB_Info GxB_Scalar_setElement_UINT8(GrB_Scalar, uint8_t); +GrB_Info GxB_Scalar_setElement_UINT16(GrB_Scalar, uint16_t); +GrB_Info GxB_Scalar_setElement_UINT32(GrB_Scalar, uint32_t); +GrB_Info GxB_Scalar_setElement_UINT64(GrB_Scalar, uint64_t); +GrB_Info GxB_Scalar_set_arenas(GrB_Scalar *Shandle, const int new_header_arena, const int new_data_arena); +GrB_Info GxB_Scalar_type(GrB_Type *type, const GrB_Scalar s); +GrB_Info GxB_Scalar_type_name(char *, const GrB_Scalar); +GrB_Info GxB_Scalar_wait(GrB_Scalar *); +GrB_Info GxB_Serialized_get_Scalar(const void *, GrB_Scalar, int, size_t); + +/* selectop */ +GrB_Info GxB_SelectOp_fprint(GxB_SelectOp, const char *, int, FILE *); +GrB_Info GxB_SelectOp_ttype(GrB_Type *, GxB_SelectOp); +GrB_Info GxB_SelectOp_xtype(GrB_Type *, GxB_SelectOp); + +/* semiring */ +GrB_Info GxB_Semiring_add(GrB_Monoid *, GrB_Semiring); +GrB_Info GxB_Semiring_fprint(GrB_Semiring semiring, const char *name, int pr, FILE *f); +GrB_Info GxB_Semiring_multiply(GrB_BinaryOp *, GrB_Semiring); +GrB_Info GxB_Semiring_new_arena(GrB_Semiring *semiring, GrB_Monoid add, GrB_BinaryOp multiply, const int header_arena); + +/* type */ +GrB_Info GxB_Type_fprint(GrB_Type type, const char *name, int pr, FILE *f); +GrB_Info GxB_Type_from_name(GrB_Type *type, const char *type_name); +GrB_Info GxB_Type_name(char *, const GrB_Type); +GrB_Info GxB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *type_name, const char *type_defn); +GrB_Info GxB_Type_new_arena(GrB_Type *type, size_t sizeof_type, const char *type_name, const char *type_defn, const int header_arena); +GrB_Info GxB_Type_size(size_t *, const GrB_Type); + +/* unary */ +GrB_Info GxB_UnaryOp_fprint(GrB_UnaryOp unaryop, const char *name, int pr, FILE *f); +GrB_Info GxB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn); +GrB_Info GxB_UnaryOp_new_arena(GrB_UnaryOp *op_handle, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn, const int header_arena); +GrB_Info GxB_UnaryOp_xtype(GrB_Type *, GrB_UnaryOp); +GrB_Info GxB_UnaryOp_xtype_name(char *, const GrB_UnaryOp); +GrB_Info GxB_UnaryOp_ztype(GrB_Type *, GrB_UnaryOp); +GrB_Info GxB_UnaryOp_ztype_name(char *, const GrB_UnaryOp); + +/* vector */ +GrB_Info GxB_Vector_Iterator_attach(GxB_Iterator iterator, GrB_Vector v, GrB_Descriptor desc); +GrB_Info GxB_Vector_Option_get(GrB_Vector, int, ...); +GrB_Info GxB_Vector_Option_get_FP64(GrB_Vector, int, double *); +GrB_Info GxB_Vector_Option_get_INT32(GrB_Vector, int, int32_t *); +GrB_Info GxB_Vector_Option_set(GrB_Vector, int, ...); +GrB_Info GxB_Vector_Option_set_FP64(GrB_Vector, int, double); +GrB_Info GxB_Vector_Option_set_INT32(GrB_Vector, int, int32_t); +GrB_Info GxB_Vector_apply_BinaryOp1st(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Scalar, const GrB_Vector, const GrB_Descriptor); +GrB_Info GxB_Vector_apply_BinaryOp2nd(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GrB_BinaryOp, const GrB_Vector, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Vector_assign_Scalar_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_assign_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_build_Scalar(GrB_Vector w, const GrB_Index *I_, const GrB_Scalar scalar, GrB_Index nvals); +GrB_Info GxB_Vector_build_Scalar_Vector(GrB_Vector w, const GrB_Vector I_vector, const GrB_Scalar scalar, const GrB_Descriptor desc); +GrB_Info GxB_Vector_build_Vector(GrB_Vector w, const GrB_Vector I_vector, const GrB_Vector X_vector, const GrB_BinaryOp dup, const GrB_Descriptor desc); +GrB_Info GxB_Vector_deserialize(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); +GrB_Info GxB_Vector_deserialize_arena(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const int header_arena, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Vector_dup_arena(GrB_Vector *w, const GrB_Vector u, const int header_arena, const int data_arena); +GrB_Info GxB_Vector_eWiseUnion(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_BinaryOp add, const GrB_Vector u, const GrB_Scalar alpha, const GrB_Vector v, const GrB_Scalar beta, const GrB_Descriptor desc); +GrB_Info GxB_Vector_export_Bitmap(GrB_Vector *, GrB_Type *, uint64_t *, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Vector_export_CSC(GrB_Vector *, GrB_Type *, uint64_t *, uint64_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Vector_export_Full(GrB_Vector *, GrB_Type *, uint64_t *, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Vector_extractTuples_Vector(GrB_Vector I_vector, GrB_Vector X_vector, const GrB_Vector V, const GrB_Descriptor desc); +GrB_Info GxB_Vector_extract_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_fprint(GrB_Vector v, const char *name, int pr, FILE *f); +GrB_Info GxB_Vector_import_Bitmap(GrB_Vector *, GrB_Type, uint64_t, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Vector_import_CSC(GrB_Vector *, GrB_Type, uint64_t, uint64_t **, void **, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_import_Full(GrB_Vector *, GrB_Type, uint64_t, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_isStoredElement(const GrB_Vector v, GrB_Index i); +GrB_Info GxB_Vector_iso(bool *, const GrB_Vector); +GrB_Info GxB_Vector_load(GrB_Vector V, void **X, GrB_Type type, uint64_t n, uint64_t X_memsize, int handling, const GrB_Descriptor desc); +GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); +GrB_Info GxB_Vector_new_arena(GrB_Vector *v, GrB_Type type, GrB_Index n, const int header_arena, const int data_arena); +GrB_Info GxB_Vector_pack_Bitmap(GrB_Vector, int8_t **, void **, uint64_t, uint64_t, bool, uint64_t, const GrB_Descriptor); +GrB_Info GxB_Vector_pack_CSC(GrB_Vector, uint64_t **, void **, uint64_t, uint64_t, bool, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_pack_Full(GrB_Vector, void **, uint64_t, bool, const GrB_Descriptor); +GrB_Info GxB_Vector_select(GrB_Vector, const GrB_Vector, const GrB_BinaryOp, const GxB_SelectOp, const GrB_Vector, const GrB_Scalar, const GrB_Descriptor); +GrB_Info GxB_Vector_serialize(void **blob_handle, GrB_Index *blob_size, GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_serialize_arena(void **blob_handle, GrB_Index *blob_size, GrB_Vector u, const int data_arena, const GrB_Descriptor desc); +GrB_Info GxB_Vector_set_arenas(GrB_Vector *Vhandle, const int new_header_arena, const int new_data_arena); +GrB_Info GxB_Vector_sort(GrB_Vector w, GrB_Vector p, GrB_BinaryOp op, GrB_Vector u, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_BOOL(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, bool x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_FP32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, float x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_FP64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, double x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_INT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, int64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_Scalar_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Scalar scalar, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UDT(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, void *x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT8(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint8_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT16(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint16_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT32(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint32_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_UINT64(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, uint64_t x, const GrB_Index *I_, GrB_Index ni, const GrB_Descriptor desc); +GrB_Info GxB_Vector_subassign_Vector(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, const GrB_Vector u, const GrB_Vector I_vector, const GrB_Descriptor desc); +GrB_Info GxB_Vector_type(GrB_Type *type, const GrB_Vector v); +GrB_Info GxB_Vector_type_name(char *, const GrB_Vector); +GrB_Info GxB_Vector_unload(GrB_Vector V, void **X, GrB_Type *type, uint64_t *n, uint64_t *X_memsize, int *handling, const GrB_Descriptor desc); +GrB_Info GxB_Vector_unpack_Bitmap(GrB_Vector, int8_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, const GrB_Descriptor); +GrB_Info GxB_Vector_unpack_CSC(GrB_Vector, uint64_t **, void **, uint64_t *, uint64_t *, bool *, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_Vector_unpack_Full(GrB_Vector, void **, uint64_t *, bool *, const GrB_Descriptor); +GrB_Info GxB_load_Vector_from_Container(GrB_Vector V, GxB_Container Container, const GrB_Descriptor desc); +GrB_Info GxB_unload_Vector_into_Container(GrB_Vector V, GxB_Container Container, const GrB_Descriptor desc); + +/* int DEFINES */ +#define GRB_SUBVERSION ... +#define GRB_VERSION ... +#define GrB_INDEX_MAX ... +#define GxB_ANY_SPARSITY ... +#define GxB_ARENA_DATA ... +#define GxB_ARENA_HEADER ... +#define GxB_AUTO_SPARSITY ... +#define GxB_BACKWARDS ... +#define GxB_BEGIN ... +#define GxB_BITMAP ... +#define GxB_CHUNK ... +#define GxB_COMPRESSION_DEFAULT ... +#define GxB_COMPRESSION_LZ4 ... +#define GxB_COMPRESSION_LZ4HC ... +#define GxB_COMPRESSION_NONE ... +#define GxB_COMPRESSION_ZSTD ... +#define GxB_END ... +#define GxB_FAST_IMPORT ... +#define GxB_FULL ... +#define GxB_GPU_IDS ... +#define GxB_HYPERSPARSE ... +#define GxB_IMPLEMENTATION ... +#define GxB_IMPLEMENTATION_MAJOR ... +#define GxB_IMPLEMENTATION_MINOR ... +#define GxB_IMPLEMENTATION_SUB ... +#define GxB_INC ... +#define GxB_INDEX_MAX ... +#define GxB_MAX_NAME_LEN ... +#define GxB_NARENAS ... +#define GxB_NARENAS_GPU ... +#define GxB_NBITMAP_SWITCH ... +#define GxB_NGPUS ... +#define GxB_NTHREADS ... +#define GxB_RANGE ... +#define GxB_SPARSE ... +#define GxB_SPEC_MAJOR ... +#define GxB_SPEC_MINOR ... +#define GxB_SPEC_SUB ... +#define GxB_SPEC_VERSION ... +#define GxB_STDC_VERSION ... +#define GxB_STRIDE ... +#define GxB_USE_VALUES ... + +/* char* DEFINES */ +extern char *GxB_IMPLEMENTATION_ABOUT_STR; +extern char *GxB_IMPLEMENTATION_DATE_STR; +extern char *GxB_IMPLEMENTATION_LICENSE_STR; +extern char *GxB_IMPLEMENTATION_NAME_STR; +extern char *GxB_SPEC_ABOUT_STR; +extern char *GxB_SPEC_DATE_STR; diff --git a/suitesparse_graphblas/tests/__init__.py b/suitesparse_graphblas/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/suitesparse_graphblas/tests/test_doctest.py b/suitesparse_graphblas/tests/test_doctest.py new file mode 100644 index 0000000..8718558 --- /dev/null +++ b/suitesparse_graphblas/tests/test_doctest.py @@ -0,0 +1,23 @@ +import doctest +import importlib +import pkgutil + +from suitesparse_graphblas import api, utils + + +def test_run_doctests(): + # Every module of the functional API, found rather than listed so none is missed: the + # wheel builds' test command does not collect doctests, so they run only through here + attempted = 0 + names = sorted(info.name for info in pkgutil.walk_packages(api.__path__, f"{api.__name__}.")) + for name in names: + mod = importlib.import_module(name) + _, tried = doctest.testmod(mod, optionflags=doctest.ELLIPSIS, raise_on_error=True) + attempted += tried + assert attempted > 0 + + # `testmod` doesn't find these: Cython functions, or wrapped by `contextmanager` + runner = doctest.DebugRunner(optionflags=doctest.ELLIPSIS) # raises on failure + for test in doctest.DocTestFinder().find(utils.give_buffer, "give_buffer", globs={}): + runner.run(test) + assert runner.tries > 0 diff --git a/suitesparse_graphblas/tests/test_exceptions.py b/suitesparse_graphblas/tests/test_exceptions.py new file mode 100644 index 0000000..26b7861 --- /dev/null +++ b/suitesparse_graphblas/tests/test_exceptions.py @@ -0,0 +1,12 @@ +import pytest + +from suitesparse_graphblas import check_status, exceptions, ffi, lib + + +def test_check_status(): + A = ffi.new("GrB_Matrix*") + check_status(A, lib.GrB_Matrix_new(A, lib.GrB_BOOL, 2, 2)) + with pytest.raises(exceptions.Panic): + check_status(A, lib.GrB_PANIC) + with pytest.raises(exceptions.Panic): + check_status(A[0], lib.GrB_PANIC) diff --git a/suitesparse_graphblas/tests/test_initialize.py b/suitesparse_graphblas/tests/test_initialize.py new file mode 100644 index 0000000..fbd4db7 --- /dev/null +++ b/suitesparse_graphblas/tests/test_initialize.py @@ -0,0 +1,10 @@ +if __name__ == "__main__": + import pytest + + import suitesparse_graphblas as ssgb + + assert ssgb.is_initialized() is False + ssgb.initialize() + assert ssgb.is_initialized() is True + with pytest.raises(RuntimeError, match="GraphBLAS is already initialized"): + ssgb.initialize() diff --git a/suitesparse_graphblas/tests/test_io.py b/suitesparse_graphblas/tests/test_io.py new file mode 100644 index 0000000..1134314 --- /dev/null +++ b/suitesparse_graphblas/tests/test_io.py @@ -0,0 +1,216 @@ +import bz2 +import gzip +import platform +from pathlib import Path + +import pytest + +from suitesparse_graphblas import ( + bool_types, + check_status, + complex_types, + ffi, + grb_types, + lib, + matrix, + real_types, + signed_integer_types, + supports_complex, + unsigned_integer_types, + vector, +) + +try: + import lzma +except ImportError: # Pyodide before 314 has it as a separate package + lzma = None + +if platform.system() == "Windows": + pytest.skip("skipping windows-only tests", allow_module_level=True) + +from suitesparse_graphblas.io import binary # isort:skip + +NULL = ffi.NULL + + +def _test_elements(T): + if T in bool_types: + return [True, False], [0, 0], [1, 1] + elif T in signed_integer_types: + return [1, -42], [0, 0], [1, 1] + elif T in unsigned_integer_types: + return [1, 42], [0, 0], [1, 1] + elif T in real_types: + return [1.0, -42.42], [0, 0], [1, 1] + elif T in complex_types: + return [complex(1.0, 1.0), complex(42.0, -42.0)], [0, 0], [1, 1] + + +_element_setters = { + lib.GrB_BOOL: lib.GrB_Matrix_setElement_BOOL, + lib.GrB_INT8: lib.GrB_Matrix_setElement_INT8, + lib.GrB_INT16: lib.GrB_Matrix_setElement_INT16, + lib.GrB_INT32: lib.GrB_Matrix_setElement_INT32, + lib.GrB_INT64: lib.GrB_Matrix_setElement_INT64, + lib.GrB_UINT8: lib.GrB_Matrix_setElement_UINT8, + lib.GrB_UINT16: lib.GrB_Matrix_setElement_UINT16, + lib.GrB_UINT32: lib.GrB_Matrix_setElement_UINT32, + lib.GrB_UINT64: lib.GrB_Matrix_setElement_UINT64, + lib.GrB_FP32: lib.GrB_Matrix_setElement_FP32, + lib.GrB_FP64: lib.GrB_Matrix_setElement_FP64, +} + +if supports_complex(): + _element_setters.update( + { + lib.GxB_FC32: lib.GxB_Matrix_setElement_FC32, + lib.GxB_FC64: lib.GxB_Matrix_setElement_FC64, + } + ) + + +_eq_ops = { + lib.GrB_BOOL: lib.GrB_EQ_BOOL, + lib.GrB_INT8: lib.GrB_EQ_INT8, + lib.GrB_INT16: lib.GrB_EQ_INT16, + lib.GrB_INT32: lib.GrB_EQ_INT32, + lib.GrB_INT64: lib.GrB_EQ_INT64, + lib.GrB_UINT8: lib.GrB_EQ_UINT8, + lib.GrB_UINT16: lib.GrB_EQ_UINT16, + lib.GrB_UINT32: lib.GrB_EQ_UINT32, + lib.GrB_UINT64: lib.GrB_EQ_UINT64, + lib.GrB_FP32: lib.GrB_EQ_FP32, + lib.GrB_FP64: lib.GrB_EQ_FP64, +} + +if supports_complex(): + _eq_ops.update( + { + lib.GxB_FC32: lib.GxB_EQ_FC32, + lib.GxB_FC64: lib.GxB_EQ_FC64, + } + ) + + +def test_serialize_matrix(): + T = lib.GrB_INT64 + A = matrix.matrix_new(T, 2, 2) + for args in zip(*_test_elements(T)): + f = _element_setters[T] + check_status(A, f(A[0], *args)) + data = matrix.serialize(A) + B = matrix.deserialize(data) + + # Test equal + C = matrix.matrix_new(lib.GrB_BOOL, 2, 2) + check_status( + C, + lib.GrB_Matrix_eWiseAdd_BinaryOp(C[0], NULL, NULL, _eq_ops[T], A[0], B[0], NULL), + ) + assert matrix.matrix_nvals(A) == matrix.matrix_nvals(B) == matrix.matrix_nvals(C) + is_eq = ffi.new("bool*") + check_status( + C, + lib.GrB_Matrix_reduce_BOOL(is_eq, NULL, lib.GrB_LAND_MONOID_BOOL, C[0], NULL), + ) + assert is_eq[0] + + +def test_serialize_vector(): + T = lib.GrB_INT64 + v = vector.vector_new(T, 3) + check_status(v, lib.GrB_Vector_setElement_INT64(v[0], 2, 0)) + check_status(v, lib.GrB_Vector_setElement_INT64(v[0], 10, 1)) + data = vector.serialize(v, lib.GxB_COMPRESSION_LZ4HC, level=7) + w = vector.deserialize(data) + + # Test equal + x = vector.vector_new(lib.GrB_BOOL, 3) + check_status( + x, + lib.GrB_Vector_eWiseAdd_BinaryOp(x[0], NULL, NULL, _eq_ops[T], v[0], w[0], NULL), + ) + assert vector.vector_nvals(v) == vector.vector_nvals(w) == vector.vector_nvals(x) + is_eq = ffi.new("bool*") + check_status( + x, + lib.GrB_Vector_reduce_BOOL(is_eq, NULL, lib.GrB_LAND_MONOID_BOOL, x[0], NULL), + ) + assert is_eq[0] + + +def test_matrix_binfile_read_write(tmp_path): + openers = [Path.open, gzip.open, bz2.open] + if lzma is not None: + openers.append(lzma.open) + for opener in openers: + for format in (lib.GxB_BY_ROW, lib.GxB_BY_COL): + for T in grb_types: + for sparsity in (lib.GxB_HYPERSPARSE, lib.GxB_SPARSE, lib.GxB_BITMAP, lib.GxB_FULL): + A = matrix.matrix_new(T, 2, 2) + + if T is not lib.GxB_FULL: + for args in zip(*_test_elements(T)): + f = _element_setters[T] + check_status(A, f(A[0], *args)) + else: + Tone = _test_elements(T)[0][0] + check_status( + A[0], + lib.GrB_assign( + A, + NULL, + NULL, + Tone, + lib.GrB_ALL, + 0, + lib.GrB_ALL, + 0, + NULL, + ), + ) + matrix.matrix_set_sparsity_control(A, sparsity) + matrix.matrix_set_format(A, format) + + binfilef = tmp_path / "binfilewrite_test.binfile" + binary.binwrite(A, binfilef, opener=opener) + B = binary.binread(binfilef, opener=opener) + + assert matrix.matrix_type(A) == matrix.matrix_type(B) + assert matrix.matrix_nrows(A) == matrix.matrix_nrows(B) + assert matrix.matrix_ncols(A) == matrix.matrix_ncols(B) + assert matrix.matrix_hyper_switch(A) == matrix.matrix_hyper_switch(B) + assert matrix.matrix_bitmap_switch(A) == matrix.matrix_bitmap_switch(B) + # assert matrix.matrix_sparsity_control(A) == matrix.matrix_sparsity_control(B) + + C = matrix.matrix_new(lib.GrB_BOOL, 2, 2) + + check_status( + C, + lib.GrB_Matrix_eWiseAdd_BinaryOp( + C[0], NULL, NULL, _eq_ops[T], A[0], B[0], NULL + ), + ) + + assert ( + matrix.matrix_nvals(A) == matrix.matrix_nvals(B) == matrix.matrix_nvals(C) + ) + + is_eq = ffi.new("bool*") + check_status( + C, + lib.GrB_Matrix_reduce_BOOL( + is_eq, NULL, lib.GrB_LAND_MONOID_BOOL, C[0], NULL + ), + ) + + assert is_eq[0] + + +def test_binwrite_failure_keeps_matrix(tmp_path): + # `binwrite` unpacks the matrix to write its arrays, and must put them back regardless + A = matrix.matrix_new(lib.GrB_INT64, 2, 2) + check_status(A, lib.GrB_Matrix_setElement_INT64(A[0], 1, 0, 0)) + with pytest.raises(OSError): + binary.binwrite(A, tmp_path / "missing_directory" / "matrix.binfile") + assert matrix.matrix_nvals(A) == 1 diff --git a/suitesparse_graphblas/tests/test_jit.py b/suitesparse_graphblas/tests/test_jit.py new file mode 100644 index 0000000..1921928 --- /dev/null +++ b/suitesparse_graphblas/tests/test_jit.py @@ -0,0 +1,39 @@ +from suitesparse_graphblas import ffi, lib + + +def test_print_jit_config(): + print() + print("===================================") + print("Printing default JIT configurations") + print("-----------------------------------") + jit_c_control = { + lib.GxB_JIT_OFF: "off", + lib.GxB_JIT_PAUSE: "pause", + lib.GxB_JIT_RUN: "run", + lib.GxB_JIT_LOAD: "load", + lib.GxB_JIT_ON: "on", + } + val_ptr = ffi.new("int32_t*") + assert lib.GxB_Global_Option_get_INT32(lib.GxB_JIT_C_CONTROL, val_ptr) == lib.GrB_SUCCESS + print("JIT_C_CONTROL", jit_c_control[val_ptr[0]]) + + assert lib.GxB_Global_Option_get_INT32(lib.GxB_JIT_USE_CMAKE, val_ptr) == lib.GrB_SUCCESS + print("JIT_USE_CMAKE", bool(val_ptr[0])) + + func = lib.GxB_Global_Option_get_CHAR + names = [ + "JIT_C_COMPILER_NAME", + "JIT_C_COMPILER_FLAGS", + "JIT_C_LINKER_FLAGS", + "JIT_C_LIBRARIES", + "JIT_C_CMAKE_LIBS", + "JIT_C_PREFACE", + "JIT_ERROR_LOG", + "JIT_CACHE_PATH", + ] + val_ptr = ffi.new("char**") + for name in names: + obj = getattr(lib, f"GxB_{name}") + assert func(obj, val_ptr) == lib.GrB_SUCCESS + print(name, ffi.string(val_ptr[0]).decode()) + print("===================================") diff --git a/suitesparse_graphblas/tests/test_memory.py b/suitesparse_graphblas/tests/test_memory.py new file mode 100644 index 0000000..03ef601 --- /dev/null +++ b/suitesparse_graphblas/tests/test_memory.py @@ -0,0 +1,362 @@ +import os +import subprocess +import sys +import textwrap + +import numpy as np +import pytest + +from suitesparse_graphblas import check_status, exceptions, ffi, lib, matrix, vector +from suitesparse_graphblas.utils import ( + can_unclaim_buffer, + claim_buffer, + claim_buffer_2d, + empty, + give_buffer, + unclaim_buffer, +) + +# Move memory between GraphBLAS and NumPy every supported way, then free all of it. +# `binary` is not tested on Windows; see test_io.py. +SCRIPT = textwrap.dedent(""" + import gc + import sys + import threading + from pathlib import Path + + import numpy as np + + import suitesparse_graphblas as ssgb + from suitesparse_graphblas import check_status, ffi, lib, matrix, vector + from suitesparse_graphblas.api import context + from suitesparse_graphblas.utils import can_unclaim_buffer, claim_buffer, empty, give_buffer + + memory_manager, tmpdir = sys.argv[1], Path(sys.argv[2]) + ssgb.initialize(memory_manager=memory_manager) + # NumPy warns (here, raises) when it frees an array without a memory handler (see the + # subprocess environment), but from deallocation, where it can only report it + unraisable = [] + sys.unraisablehook = unraisable.append + int64 = np.dtype(np.int64) + # NumPy keeps freed blocks under 1024 bytes for reuse, which would hide a wrong free + N = 1000 + + + def load(array, **kwargs): + # NumPy -> GraphBLAS, the way to use `give_buffer` + v = vector.vector_new(lib.GrB_INT64) + with give_buffer(array, **kwargs) as (X, nbytes, arena): + info = lib.GxB_Vector_load( + v[0], X, lib.GrB_INT64, array.size, nbytes, lib.GrB_DEFAULT + arena, ffi.NULL + ) + check_status(v, info) + assert vector.vector_nvals(v) == array.size + return v + + + def unload(v): + # GraphBLAS -> NumPy, the way to use `claim_buffer` + X = ffi.new("void**") + n = ffi.new("uint64_t*") + handling = ffi.new("int*") + info = lib.GxB_Vector_unload( + v[0], X, ffi.new("GrB_Type*"), n, ffi.new("uint64_t*"), handling, ffi.NULL + ) + check_status(v, info) + assert handling[0] < lib.GxB_IS_READONLY # else the data is not GraphBLAS's to give + return claim_buffer(ffi, X[0], n[0], int64, arena=handling[0] - lib.GrB_DEFAULT) + + + def roundtrip(**kwargs): + # NumPy -> GraphBLAS -> NumPy: without a copy (if "numpy"), with one, and from `empty` + ones = empty(N, int64, **kwargs) + ones[:] = 1 + for array in [np.arange(N, dtype=int64), np.arange(2 * N, dtype=int64)[::2], ones]: + total = array.sum() + assert unload(load(array, **kwargs)).sum() == total + v = load(np.arange(N, dtype=int64), **kwargs) + data = vector.serialize(v, lib.GxB_COMPRESSION_NONE) + assert data.nbytes > N * 8 + assert vector.vector_nvals(vector.deserialize(data)) == N + + + def main(): + array = np.arange(N, dtype=int64) + assert can_unclaim_buffer(array) == (memory_manager == "numpy") + load(array) + assert array.flags.owndata == (memory_manager != "numpy") # was it copied? + roundtrip() + + # GraphBLAS has nothing to give for an empty array, so NumPy allocates it + assert claim_buffer(ffi, ffi.NULL, 0, int64).shape == (0,) + + # The same array as two arguments: GraphBLAS must get two buffers + array = np.arange(N, dtype=np.uint64) + A = matrix.matrix_new(lib.GrB_UINT64, 1, N) + with ( + give_buffer(np.array([0, N], np.uint64), "GrB_Index*") as (Ap, Ap_size, _), + give_buffer(array, "GrB_Index*") as (Aj, Aj_size, _), + give_buffer(array) as (Ax, Ax_size, _), + ): + info = lib.GxB_Matrix_pack_CSR( + A[0], Ap, Aj, Ax, Ap_size, Aj_size, Ax_size, False, False, ffi.NULL + ) + check_status(A, info) + assert matrix.matrix_nvals(A) == N + + # Many threads at once (free-threaded Python runs them in parallel) + def roundtrips(): + for _ in range(20): + roundtrip() + + threads = [threading.Thread(target=roundtrips) for _ in range(8)] + for t in threads: + t.start() + for t in threads: + t.join() + + if sys.platform == "win32": + return + from suitesparse_graphblas.io import binary + + # `binread` hands its buffers to GraphBLAS; an iso matrix stores a single value, and + # making it non-iso later must not write past it + for sparsity in [lib.GxB_HYPERSPARSE, lib.GxB_SPARSE, lib.GxB_BITMAP, lib.GxB_FULL]: + A = matrix.matrix_new(lib.GrB_INT64, 30, 30) + info = lib.GrB_Matrix_assign_INT64( + A[0], ffi.NULL, ffi.NULL, 7, lib.GrB_ALL, 30, lib.GrB_ALL, 30, ffi.NULL + ) + check_status(A, info) + matrix.matrix_set_sparsity_control(A, sparsity) + binary.binwrite(A, tmpdir / "iso.binfile") + B = binary.binread(tmpdir / "iso.binfile") + matrix.set_int64(B, 99, 0, 0) + check_status(B, lib.GrB_Matrix_wait(B[0], lib.GrB_MATERIALIZE)) + assert matrix.matrix_nvals(B) == 900 + + # Another arena, using libc's allocator + k = lib.GxB_NARENAS - 1 + import cffi + + std = cffi.FFI() + std.cdef("void *malloc(size_t); void *calloc(size_t, size_t);") + std.cdef("void *realloc(void *, size_t); void free(void *);") + libc = std.dlopen(None) + funcs = [ + ffi.cast(sig, int(std.cast("uintptr_t", std.addressof(libc, name)))) + for name, sig in [ + ("malloc", "void *(*)(size_t)"), + ("calloc", "void *(*)(size_t, size_t)"), + ("realloc", "void *(*)(void *, size_t)"), + ("free", "void (*)(void *)"), + ] + ] + assert lib.GxB_arena_init(k, *funcs) == lib.GrB_SUCCESS + array = empty(N, int64, arena=k) + assert can_unclaim_buffer(array, arena=k) and not can_unclaim_buffer(array, arena=0) + assert not can_unclaim_buffer(np.arange(N), arena=k) + roundtrip(arena=k) + + def others(): + # GraphBLAS -> NumPy and NumPy -> GraphBLAS in functions that have no `arena` + roundtrip() + binary.binwrite(A, tmpdir / "arena.binfile") + assert matrix.matrix_nvals(binary.binread(tmpdir / "arena.binfile")) == 900 + + # ...as the global data arena, which is then the default + assert lib.GrB_Global_set_INT32(lib.GrB_GLOBAL, k, lib.GxB_ARENA_DATA) == lib.GrB_SUCCESS + assert can_unclaim_buffer(empty(N)) and not can_unclaim_buffer(np.arange(N)) + others() + assert lib.GrB_Global_set_INT32(lib.GrB_GLOBAL, 0, lib.GxB_ARENA_DATA) == lib.GrB_SUCCESS + + # ...and as the data arena of an engaged Context, which GraphBLAS doesn't reveal + ctx = context.context_new() + check_status(ctx, lib.GxB_Context_set_INT(ctx[0], k, lib.GxB_ARENA_DATA)) + context.context_engage(ctx) + others() + context.context_disengage(ctx) + + + main() + gc.collect() + assert not unraisable, [str(u.exc_value) for u in unraisable] + """) + + +@pytest.mark.skipif(sys.platform == "emscripten", reason="needs a subprocess") +@pytest.mark.parametrize("memory_manager", ["numpy", "c"]) +def test_allocators_match(memory_manager, tmp_path): + """Memory must be freed by the allocator that allocated it, whoever ends up owning it. + + A mismatch is silent wherever both allocators happen to be libc's, which used to be + everywhere. They differ on free-threaded Python 3.15, and Python's debug hooks make + them differ on any Python (given NumPy >=2.5), so this test doesn't depend on which + Python runs it. It needs its own process: a mismatch aborts the interpreter, and + GraphBLAS can only be initialized once. + """ + proc = subprocess.run( + [ + sys.executable, + "-W", + "error::RuntimeWarning", + "-c", + SCRIPT, + memory_manager, + str(tmp_path), + ], + env={**os.environ, "PYTHONMALLOC": "debug", "NUMPY_WARN_IF_NO_MEM_POLICY": "1"}, + capture_output=True, + text=True, + timeout=300, + ) + assert proc.returncode == 0, proc.stderr + + +def load(array, **kwargs): + v = vector.vector_new(lib.GrB_INT64) + with give_buffer(array, **kwargs) as (X, nbytes, arena): + info = lib.GxB_Vector_load( + v[0], X, lib.GrB_INT64, array.size, nbytes, lib.GrB_DEFAULT + arena, ffi.NULL + ) + check_status(v, info) + return v + + +def test_claim_buffer(): + int64 = np.dtype(np.int64) + assert claim_buffer(ffi, ffi.NULL, 0, int64).shape == (0,) + assert claim_buffer_2d(ffi, ffi.NULL, 0, 0, 5, int64, True).shape == (0, 5) + with pytest.raises(ValueError, match="NULL pointer"): + claim_buffer(ffi, ffi.NULL, 3, int64) + with pytest.raises(ValueError, match="NULL pointer"): + claim_buffer_2d(ffi, ffi.NULL, 6, 2, 3, int64, True) + + +def test_can_unclaim_buffer(): + array = np.arange(10) + assert can_unclaim_buffer(array) + assert can_unclaim_buffer(matrix.serialize(matrix.matrix_new(lib.GrB_BOOL, 2, 2))) + assert can_unclaim_buffer(empty(3)) + # GraphBLAS can only take ownership from an owner, and only if it may change the data + assert not can_unclaim_buffer(array[:5]) + assert not can_unclaim_buffer(np.frombuffer(b"1234", np.uint8)) + readonly = np.arange(10) + readonly.flags.writeable = False + assert not can_unclaim_buffer(readonly) + assert not can_unclaim_buffer(np.array([None, 1])) + assert not can_unclaim_buffer([1, 2, 3]) + for arena in [8, -1, 2**40]: + with pytest.raises(ValueError, match="range"): + can_unclaim_buffer(array, arena=arena) + with pytest.raises(ValueError, match="arena 5 has not been initialized"): + can_unclaim_buffer(array, arena=5) + + +def test_unclaim_buffer(): + def handover(array): + # The low-level way: hand over (after checking `can_unclaim_buffer`), then unclaim + v = vector.vector_new(lib.GrB_INT64) + X = ffi.new("void**", ffi.cast("void*", array.ctypes.data)) + info = lib.GxB_Vector_load( + v[0], X, lib.GrB_INT64, array.size, array.nbytes, lib.GrB_DEFAULT, ffi.NULL + ) + check_status(v, info) + return v + + array = np.arange(10, dtype=np.int64) + assert can_unclaim_buffer(array) + v = handover(array) + unclaim_buffer(array) + assert not array.flags.owndata + assert not array.flags.writeable + assert vector.vector_nvals(v) == 10 + + # GraphBLAS should not have been given this, but it now has it, so NumPy must let go + array = np.arange(10, dtype=np.int64) + array.flags.writeable = False + assert not can_unclaim_buffer(array) + v = handover(array) + with pytest.raises(ValueError, match="it is read-only. Check `can_unclaim_buffer`"): + unclaim_buffer(array) + assert not array.flags.owndata + assert vector.vector_nvals(v) == 10 + + for array in [np.arange(10)[::2], np.frombuffer(bytearray(8), np.uint8)]: + with pytest.raises(ValueError, match="does not own its data"): + unclaim_buffer(array) + assert array.flags.writeable # unchanged + + +def test_empty(): + a = empty((2, 3), np.int32) + assert a.shape == (2, 3) + assert a.dtype == np.int32 + assert a.flags.c_contiguous + assert a.flags.owndata + a[...] = 1 + assert a.sum() == 6 + f = empty([2, 3], order="F") + assert f.dtype == np.float64 + assert f.flags.f_contiguous + assert not f.flags.c_contiguous + assert empty(4).shape == empty(np.int64(4)).shape == (4,) + assert empty(()).shape == () + assert empty((0, 5)).size == 0 + with pytest.raises(ValueError, match="negative"): + empty(-1) + with pytest.raises(TypeError, match="sequence of ints"): + empty(1.5) + with pytest.raises(TypeError, match="Python objects"): + empty(3, object) + with pytest.raises(ValueError, match="order"): + empty(3, order="A") + + +def test_give_buffer(): + # Zero-copy: the array no longer owns the data GraphBLAS took + array = np.arange(5, dtype=np.int64) + v = load(array) + assert not array.flags.owndata + assert not array.flags.writeable + x = ffi.new("int64_t*") + check_status(v, lib.GrB_Vector_extractElement_INT64(x, v[0], 4)) + assert x[0] == 4 + + # A copy, so the array is unchanged + for array, kwargs in [ + (np.arange(10, dtype=np.int64)[::2], {}), + (np.arange(5, dtype=np.int64), {"copy": True}), + ]: + v = load(array, **kwargs) + assert array.flags.writeable + check_status(v, lib.GrB_Vector_extractElement_INT64(x, v[0], 4)) + assert x[0] == array[4] + with pytest.raises(ValueError, match="without copying: it does not own its data"): + load(np.arange(10)[::2], copy=False) + + # GraphBLAS didn't take ownership, so the array keeps it + array = np.arange(5, dtype=np.int64) + v = vector.vector_new(lib.GrB_INT64) + with pytest.raises(exceptions.InvalidValue): + with give_buffer(array) as (X, nbytes, arena): + assert not array.flags.owndata # so that it can't be given twice + info = lib.GxB_Vector_load( # claims more entries than fit + v[0], X, lib.GrB_INT64, array.size + 1, nbytes, lib.GrB_DEFAULT, ffi.NULL + ) + check_status(v, info) + assert array.flags.owndata + assert array.flags.writeable + + # The same array twice: the second is a copy, or an error if it may not be + array = np.arange(5, dtype=np.int64) + with give_buffer(array) as (X, _, _), give_buffer(array) as (Y, _, _): + assert X[0] != Y[0] + with pytest.raises(ValueError, match="already being given"): + with give_buffer(array), give_buffer(array, copy=False): + pass + assert array.flags.owndata + + with pytest.raises(TypeError, match="Python objects"): + load(np.array([None, 1])) + with pytest.raises(TypeError, match="copy"): + load(np.arange(5), copy="yes") diff --git a/suitesparse_graphblas/tests/test_package.py b/suitesparse_graphblas/tests/test_package.py new file mode 100644 index 0000000..99563cb --- /dev/null +++ b/suitesparse_graphblas/tests/test_package.py @@ -0,0 +1,73 @@ +import sys + +import pytest + +import suitesparse_graphblas +from suitesparse_graphblas import ffi, lib + + +def test_matrix_existence(): + assert hasattr(lib, "GrB_Matrix_new") + + +def test_version(): + # Example dev version: 9.4.5.0+2.g5590dba8.dirty + # Example reslease version: 9.4.5.0 + version = suitesparse_graphblas.__version__ + version = [int(x) for x in version.split("+")[0].split(".")] + assert version > [9, 4, 4, 0] + + +@pytest.mark.skipif( + sys.platform == "emscripten", reason="WebAssembly (Pyodide) has no threads, so no OpenMP" +) +def test_openmp(): + # GraphBLAS only warns at configure time when OpenMP is missing and still + # builds a working, but serial, library, so a serial build is invisible + # from the outside: conda-forge's graphblas 10.5.0 shipped that way on + # osx-arm64. Wheels build GraphBLAS from source in suitesparse.sh, where + # macOS has to point CMake at Homebrew's libomp by hand, so the same slip + # is possible here. + val_ptr = ffi.new("int32_t*") + info = lib.GrB_Global_get_INT32(lib.GrB_GLOBAL, val_ptr, lib.GxB_LIBRARY_OPENMP) + assert info == lib.GrB_SUCCESS + assert val_ptr[0], "libgraphblas was built without OpenMP" + + +def test_libgraphblas_version_matches_the_loaded_library(): + """The GraphBLAS this extension was compiled against must be the one it loads. + + ``libgraphblas_version`` reads cffi ``#define`` constants, which are + resolved when the C extension is compiled against a particular + GraphBLAS.h. The values below come from the shared library actually loaded + at runtime. When those disagree, every cffi call is reading a struct laid + out by a different build -- a mismatch that surfaces later as an + unexplained ``GrB_OUT_OF_MEMORY`` or a crash, never as an import error. + """ + val_ptr = ffi.new("int32_t*") + runtime = [] + for field in ( + lib.GrB_LIBRARY_VER_MAJOR, + lib.GrB_LIBRARY_VER_MINOR, + lib.GrB_LIBRARY_VER_PATCH, + ): + assert lib.GrB_Global_get_INT32(lib.GrB_GLOBAL, val_ptr, field) == lib.GrB_SUCCESS + runtime.append(val_ptr[0]) + assert tuple(runtime) == suitesparse_graphblas.libgraphblas_version + + +def test_version_tracks_libgraphblas(): + """A released version's first three parts are the SuiteSparse:GraphBLAS version. + + That convention is what lets a caller infer the library version from the + package version, and it only holds for a release: between releases the + version reports the previous tag, which is why ``libgraphblas_version`` + exists and why anything gating on a library feature should read that + instead. Skipped on a development build rather than asserted, since + disagreeing there is the expected state, not a defect. + """ + version = suitesparse_graphblas.__version__ + if "+" in version: + pytest.skip(f"development build between releases: {version}") + parts = tuple(int(x) for x in version.split(".")[:3]) + assert parts == suitesparse_graphblas.libgraphblas_version diff --git a/suitesparse_graphblas/tests/test_scalar.py b/suitesparse_graphblas/tests/test_scalar.py new file mode 100644 index 0000000..d413c29 --- /dev/null +++ b/suitesparse_graphblas/tests/test_scalar.py @@ -0,0 +1,12 @@ +import pytest + +from suitesparse_graphblas import ffi, lib, supports_complex # noqa: F401 + + +@pytest.mark.skipif("not supports_complex()") +def test_complex(): + s = ffi.new("GrB_Scalar*") + success = lib.GrB_SUCCESS + assert lib.GrB_Scalar_new(s, lib.GxB_FC64) == success + assert lib.GxB_Scalar_setElement_FC64(s[0], 1j) == success + assert lib.GrB_Scalar_free(s) == success diff --git a/suitesparse_graphblas/utils.pxd b/suitesparse_graphblas/utils.pxd new file mode 100644 index 0000000..05da4ff --- /dev/null +++ b/suitesparse_graphblas/utils.pxd @@ -0,0 +1,69 @@ +from cpython.ref cimport PyObject +from libc.stdint cimport int32_t, uint8_t +from numpy cimport dtype as dtype_t +from numpy cimport ndarray, npy_intp + + +cdef extern from "numpy/arrayobject.h" nogil: + # These aren't public (i.e., "extern"), but other projects use them too + void *PyDataMem_NEW(size_t size) + void *PyDataMem_NEW_ZEROED(size_t nmemb, size_t size) + void *PyDataMem_RENEW(void *ptr, size_t size) + void PyDataMem_FREE(void *ptr) + # The memory handler (a PyCapsule) whose allocator matches the functions above + PyObject *PyDataMem_DefaultHandler + # NumPy memory handlers (NEP 49); like `mem_handler`, these need + # NPY_TARGET_VERSION >= NPY_1_22_API_VERSION (see setup.py) + ctypedef struct PyDataMemAllocator: + void *ctx + void *(*malloc)(void *ctx, size_t size) noexcept nogil + void *(*calloc)(void *ctx, size_t nelem, size_t elsize) noexcept nogil + void *(*realloc)(void *ctx, void *ptr, size_t new_size) noexcept nogil + void (*free)(void *ctx, void *ptr, size_t size) noexcept nogil + ctypedef struct PyDataMem_Handler: + char name[127] + uint8_t version + PyDataMemAllocator allocator + ctypedef struct PyArrayObject_fields: + PyObject *mem_handler + # These are available in newer Cython versions + void PyArray_ENABLEFLAGS(ndarray array, int flags) + void PyArray_CLEARFLAGS(ndarray array, int flags) + # Not exposed by Cython (b/c it steals a reference from dtype) + ndarray PyArray_NewFromDescr( + type subtype, dtype_t dtype, int nd, npy_intp *dims, npy_intp *strides, void *data, int flags, object obj + ) + +ctypedef enum GrB_Mode: + GrB_NONBLOCKING + GrB_BLOCKING + +# GrB_Info is a C enum (int); errors are negative +ctypedef int (*GxB_init)( + GrB_Mode, + void *(*user_malloc_function)(size_t), + void *(*user_calloc_function)(size_t, size_t), + void *(*user_realloc_function)(void *, size_t), + void (*user_free_function)(void *), +) +# GrB_Global_get_INT32 +ctypedef int (*global_get_int32_t)(void *, int32_t *, int) noexcept nogil + +cpdef int call_gxb_init(object ffi, object lib, int mode) + +cpdef ndarray claim_buffer(object ffi, object cdata, size_t size, dtype_t dtype, object arena=*) + +cpdef ndarray claim_buffer_2d( + object ffi, + object cdata, + size_t cdata_size, + size_t nrows, + size_t ncols, + dtype_t dtype, + bint is_c_order, + object arena=*, +) + +cpdef bint can_unclaim_buffer(object array, object arena=*) except -1 + +cpdef unclaim_buffer(ndarray array, object arena=*) diff --git a/suitesparse_graphblas/utils.pyx b/suitesparse_graphblas/utils.pyx new file mode 100644 index 0000000..1330f7d --- /dev/null +++ b/suitesparse_graphblas/utils.pyx @@ -0,0 +1,469 @@ +# cython: freethreading_compatible=True +# +# We don't do anything special to support free-threading, but GraphBLAS C +# libraries are required to be thread-safe, so things should "just work". +# Of course, users writing multithreaded code can find many creative ways +# to fail, but python-suitesparse-graphblas shouldn't crash. +"""Move memory between GraphBLAS and NumPy without copying. + +Memory must be freed by the allocator that allocated it. GraphBLAS frees the memory it +owns with the allocator of the *arena* the memory belongs to: arena 0 is set up by +``suitesparse_graphblas.initialize`` (NumPy's allocator for ``memory_manager="numpy"``, +libc's for ``"c"``), and ``GxB_arena_init`` can add more. NumPy frees the data of an +array with the array's memory handler (NEP 49). So: + +- GraphBLAS -> NumPy: ``claim_buffer`` and ``claim_buffer_2d`` wrap memory GraphBLAS + allocated in an array whose memory handler frees it with the same arena's allocator. +- NumPy -> GraphBLAS: ``give_buffer`` hands the data of an array to a GraphBLAS function + that takes ownership of it, such as ``GxB_Matrix_pack_CSR`` or ``GxB_Vector_load`` + (copying it first if GraphBLAS can't own it). ``can_unclaim_buffer`` and + ``unclaim_buffer`` are the lower-level pieces. +- ``empty`` makes an array that GraphBLAS can always take ownership of. + +Each function takes an optional ``arena``. It defaults to GraphBLAS's global data arena +(``GxB_ARENA_DATA`` of ``GrB_GLOBAL``; 0 unless changed), which is where GraphBLAS +allocates, and where it expects memory it is given to be from, unless the calling thread +has engaged a ``GxB_Context`` with another data arena. GraphBLAS can't be asked which +Context is engaged, so pass ``arena`` in that case. + +Which arena a buffer from GraphBLAS is in: ``GxB_*_unpack_*`` and ``GxB_*_export_*`` first +move the object to the arena above, so their buffers are in it whatever arena the object +was made in; ``GxB_*_unload`` reports each buffer's arena (``handling - GrB_DEFAULT``). +""" +import operator +import threading +from contextlib import contextmanager + +import numpy as np + +from suitesparse_graphblas._graphblas import ffi as _ffi +from suitesparse_graphblas._graphblas import lib as _lib + +from cpython.pycapsule cimport PyCapsule_GetPointer, PyCapsule_New +from cpython.pyport cimport PY_SSIZE_T_MAX +from cpython.ref cimport Py_INCREF +from libc.stdint cimport SIZE_MAX, int32_t, uintptr_t +from libc.stdio cimport snprintf +from libc.string cimport memset +from numpy cimport NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_OWNDATA, NPY_ARRAY_WRITEABLE +from numpy cimport dtype as dtype_t +from numpy cimport PyArray_CHKFLAGS, PyArray_DATA, import_array, ndarray, npy_intp + +import_array() + + +cdef enum: + NARENAS = 8 # GxB_NARENAS + +if _lib.GxB_NARENAS > NARENAS: # pragma: no cover + raise ImportError(f"Unsupported GxB_NARENAS: {_lib.GxB_NARENAS}") + +ctypedef void *(*malloc_t)(size_t) noexcept nogil +ctypedef void *(*calloc_t)(size_t, size_t) noexcept nogil +ctypedef void *(*realloc_t)(void *, size_t) noexcept nogil +ctypedef void (*free_t)(void *) noexcept nogil + +ctypedef struct Arena: + malloc_t malloc + calloc_t calloc # may be NULL + realloc_t realloc # may be NULL + free_t free + +# The allocator of each GraphBLAS arena, and a NumPy memory handler that uses it +cdef Arena arenas[NARENAS] +cdef PyDataMem_Handler arena_handlers[NARENAS] +# The NumPy memory handler (a PyCapsule) for the memory of each arena, made on first use. +# It is NumPy's default handler if the arena uses NumPy's allocator. +cdef list _handlers = [None] * NARENAS +_handlers_lock = threading.Lock() + + +cdef uintptr_t address(object cdata) except? 0: + # The address in a cffi pointer. Cython isn't compiled against GraphBLAS, so this is how + # it gets at what cffi's `lib` has: cast the result to the C type and use it directly. + return int(_ffi.cast("uintptr_t", cdata)) + + +# `GrB_Global_get_INT32(GrB_GLOBAL, ...)`, called directly rather than through cffi because +# it is on the path of every function below +cdef global_get_int32_t global_get_int32 = address( + _ffi.addressof(_lib, "GrB_Global_get_INT32") +) +cdef void *GrB_GLOBAL = address(_lib.GrB_GLOBAL) +cdef int GxB_ARENA_DATA = _lib.GxB_ARENA_DATA + + +cdef void *arena_malloc(void *ctx, size_t size) noexcept nogil: + return (ctx).malloc(size) + + +cdef void *arena_calloc(void *ctx, size_t nelem, size_t elsize) noexcept nogil: + cdef Arena *arena = ctx + cdef void *ptr + if arena.calloc != NULL: + return arena.calloc(nelem, elsize) + if elsize != 0 and nelem > SIZE_MAX // elsize: + return NULL + ptr = arena.malloc(nelem * elsize) + if ptr != NULL: + memset(ptr, 0, nelem * elsize) + return ptr + + +cdef void *arena_realloc(void *ctx, void *ptr, size_t new_size) noexcept nogil: + cdef Arena *arena = ctx + if arena.realloc == NULL: # optional for GraphBLAS arenas; NumPy raises MemoryError + return NULL + return arena.realloc(ptr, new_size) + + +cdef void arena_free(void *ctx, void *ptr, size_t size) noexcept nogil: + (ctx).free(ptr) + + +cdef int _resolve_arena(object arena) except -1: + cdef int32_t k + cdef int info + if arena is None: + info = global_get_int32(GrB_GLOBAL, &k, GxB_ARENA_DATA) + if info != 0: # GrB_SUCCESS + raise RuntimeError( + f"Unable to get GraphBLAS's data arena (info={info}); is GraphBLAS initialized?" + ) + return k + index = operator.index(arena) + if not 0 <= index < NARENAS: + raise ValueError(f"arena must be in range({NARENAS}); got {arena!r}") + return index + + +cdef object _handler(int k): + # The NumPy memory handler for memory from arena `k` + handler = _handlers[k] + if handler is None: + with _handlers_lock: + handler = _handlers[k] + if handler is None: + handler = _handlers[k] = _new_handler(k) + return handler + + +cdef object _new_handler(int k): + cdef uintptr_t funcs[4] + flag = _ffi.new("int*") + info = _lib.GxB_arena_initialized(flag, k) + if info != _lib.GrB_SUCCESS: + raise RuntimeError( + f"Unable to query GraphBLAS arena {k} (info={info}); is GraphBLAS initialized?" + ) + if not flag[0]: + raise ValueError(f"GraphBLAS arena {k} has not been initialized (see GxB_arena_init)") + func = _ffi.new("void**") + for i, field in enumerate( + [_lib.GxB_ARENA_MALLOC, _lib.GxB_ARENA_CALLOC, _lib.GxB_ARENA_REALLOC, _lib.GxB_ARENA_FREE] + ): + info = _lib.GrB_Global_get_VOID(_lib.GrB_GLOBAL, func, field + k) + if info != _lib.GrB_SUCCESS: + raise RuntimeError(f"Unable to get the allocator of GraphBLAS arena {k} (info={info})") + funcs[i] = address(func[0]) + arenas[k].malloc = funcs[0] + arenas[k].calloc = funcs[1] + arenas[k].realloc = funcs[2] + arenas[k].free = funcs[3] + if funcs[3] == PyDataMem_FREE: + # NumPy's allocator (memory_manager="numpy"): use NumPy's own handler, so these + # arrays are like any other NumPy array (including for `can_unclaim_buffer`). + return PyDataMem_DefaultHandler + snprintf(arena_handlers[k].name, sizeof(arena_handlers[k].name), "suitesparse_graphblas_arena%d", k) + arena_handlers[k].version = 1 + arena_handlers[k].allocator.ctx = &arenas[k] + arena_handlers[k].allocator.malloc = arena_malloc + arena_handlers[k].allocator.calloc = arena_calloc + arena_handlers[k].allocator.realloc = arena_realloc + arena_handlers[k].allocator.free = arena_free + return PyCapsule_New(&arena_handlers[k], "mem_handler", NULL) + + +cdef str _handler_name(object handler): + return (PyCapsule_GetPointer(handler, "mem_handler")).name.decode() + + +cdef inline void own_data(ndarray array, object handler): + # Make `array`, which was wrapped around existing data, own (and eventually free) that + # data with `handler`. Without a handler, NumPy frees with libc `free`, which is wrong + # unless the data is from libc `malloc`. + cdef PyArrayObject_fields *fields = array + if fields.mem_handler == NULL: # else NumPy allocated the data (it was given NULL) + Py_INCREF(handler) + fields.mem_handler = handler + PyArray_ENABLEFLAGS(array, NPY_ARRAY_OWNDATA) + + +cdef str _why_not_ownable(object array, object handler): + # Why GraphBLAS can't take ownership of the data of `array` (to free with `handler`), + # or None if it can. + cdef ndarray arr + cdef PyObject *mem_handler + if not isinstance(array, ndarray): + return f"it is a {type(array).__name__}, not a NumPy array" + arr = array + if not PyArray_CHKFLAGS(arr, NPY_ARRAY_OWNDATA): + return "it does not own its data (e.g., it is a view, or is already being given)" + if not PyArray_CHKFLAGS(arr, NPY_ARRAY_WRITEABLE): + return "it is read-only" + if arr.dtype.hasobject: + return "it holds Python objects" + mem_handler = (arr).mem_handler + if mem_handler == handler: + return None + if mem_handler == NULL: + return "it has no NumPy memory handler, so its data came from an unknown allocator" + return ( + f"its data came from NumPy memory handler {_handler_name(mem_handler)!r}, " + f"but GraphBLAS will free it as {_handler_name(handler)!r}" + ) + + +cpdef int call_gxb_init(object ffi, object lib, int mode): + # We need to call `GxB_init`, but we didn't compile Cython against GraphBLAS. So, we get it from cffi. + # Step 1: ffi.addressof(lib, "GxB_init") + # Return type: cffi.cdata object of a function pointer. Can't cast to int. + # Step 2: ffi.cast("uintptr_t", ...) + # Return type: cffi.cdata object of a uintptr_t type, an unsigned pointer. Can cast to int. + # Step 3: int(...) + # Return type: int. The physical address of the function. + # Step 4: (...) + # Return type: uintptr_t in Cython. Cast Python int to Cython integer for pointers. + # Step 5: (...) + # Return: function pointer in Cython! + cdef GxB_init func = int(ffi.cast("uintptr_t", ffi.addressof(lib, "GxB_init"))) + return func(mode, PyDataMem_NEW, PyDataMem_NEW_ZEROED, PyDataMem_RENEW, PyDataMem_FREE) + + +cpdef ndarray claim_buffer(object ffi, object cdata, size_t size, dtype_t dtype, object arena=None): + """Return a 1-d array that owns ``size`` elements of GraphBLAS-allocated memory at ``cdata``. + + ``arena`` is the GraphBLAS arena that allocated the memory (default: the global data + arena); NumPy will free the memory with that arena's allocator. + """ + cdef: + npy_intp dims = size + uintptr_t ptr = int(ffi.cast("uintptr_t", cdata)) + ndarray array + handler = _handler(_resolve_arena(arena)) + if ptr == 0 and size != 0: + raise ValueError(f"Unable to claim {size} elements from a NULL pointer") + Py_INCREF(dtype) + array = PyArray_NewFromDescr( + ndarray, dtype, 1, &dims, NULL, ptr, NPY_ARRAY_WRITEABLE, NULL + ) + own_data(array, handler) + return array + + +cpdef ndarray claim_buffer_2d( + object ffi, + object cdata, + size_t cdata_size, + size_t nrows, + size_t ncols, + dtype_t dtype, + bint is_c_order, + object arena=None, +): + """Like ``claim_buffer``, but return a 2-d ``nrows`` by ``ncols`` array.""" + cdef: + size_t size = nrows * ncols + ndarray array + uintptr_t ptr + npy_intp dims[2] + int flags = NPY_ARRAY_WRITEABLE + if cdata_size == size: + handler = _handler(_resolve_arena(arena)) + ptr = int(ffi.cast("uintptr_t", cdata)) + if ptr == 0 and size != 0: + raise ValueError(f"Unable to claim {size} elements from a NULL pointer") + dims[0] = nrows + dims[1] = ncols + if not is_c_order: + flags |= NPY_ARRAY_F_CONTIGUOUS + Py_INCREF(dtype) + array = PyArray_NewFromDescr( + ndarray, dtype, 2, dims, NULL, ptr, flags, NULL + ) + own_data(array, handler) + elif cdata_size > size: # pragma: no cover + array = claim_buffer(ffi, cdata, cdata_size, dtype, arena) + if is_c_order: + array = array[:size].reshape((nrows, ncols)) + else: + array = array[:size].reshape((ncols, nrows)).T + else: # pragma: no cover + raise ValueError( + f"Buffer size too small: {cdata_size}. " + f"Unable to create matrix of size {nrows}x{ncols} = {size}" + ) + return array + + +cpdef bint can_unclaim_buffer(object array, object arena=None) except -1: + """Whether GraphBLAS may take ownership of the data of ``array``. + + True only if ``array`` owns its data, is writeable, does not hold Python objects, and + its data came from the allocator of the GraphBLAS arena (default: the global data + arena) that will free it. So views never qualify, nor do arrays from a custom NumPy + memory handler, nor (with ``memory_manager="c"``) arrays NumPy allocated. Arrays from + ``claim_buffer``, ``empty``, and (with ``memory_manager="numpy"``) NumPy's default + allocator do. Prefer ``give_buffer``, which also copies when this is False. + + This cannot see other references to the data: GraphBLAS may free or reallocate it at + any time after the handover, so no view of ``array`` (nor memoryview or cffi pointer + into it) may outlive the handover. + """ + if not isinstance(array, ndarray) or not PyArray_CHKFLAGS(array, NPY_ARRAY_OWNDATA): + return False + return _why_not_ownable(array, _handler(_resolve_arena(arena))) is None + + +cpdef unclaim_buffer(ndarray array, object arena=None): + """Make ``array`` a read-only view of its data, which GraphBLAS has taken ownership of. + + Call this *after* a GraphBLAS function took ownership, and only for an array that + passed ``can_unclaim_buffer`` beforehand. Prefer ``give_buffer``, which does both. + + Raises ValueError if GraphBLAS can't own the data (see ``can_unclaim_buffer``). Since + GraphBLAS already has it and will free it, ``array`` stops owning the data even then, + so that NumPy does not free it too. + """ + why_not = _why_not_ownable(array, _handler(_resolve_arena(arena))) + if why_not is None: + PyArray_CLEARFLAGS(array, NPY_ARRAY_OWNDATA | NPY_ARRAY_WRITEABLE) + return + PyArray_CLEARFLAGS(array, NPY_ARRAY_OWNDATA) + raise ValueError( + f"GraphBLAS cannot safely own the data of this array: {why_not}. Check " + "`can_unclaim_buffer` before handing data to GraphBLAS, or use `give_buffer`." + ) + + +def empty(shape, dtype=float, order="C", arena=None): + """Return a new, uninitialized array whose data GraphBLAS can take ownership of. + + Like ``numpy.empty``, but allocated by the allocator of the GraphBLAS ``arena`` + (default: the global data arena) whatever the ``memory_manager`` or NumPy memory + handler in use, so ``can_unclaim_buffer`` is True for it. + """ + cdef: + int k = _resolve_arena(arena) + void *ptr + ndarray array + ndarray dims + handler = _handler(k) + dtype = np.dtype(dtype) + if dtype.hasobject: + raise TypeError("GraphBLAS cannot own arrays that hold Python objects") + if order not in {"C", "F"}: + raise ValueError(f"order must be 'C' or 'F'; got {order!r}") + try: + shape = (operator.index(shape),) + except TypeError: + try: + shape = tuple([operator.index(dim) for dim in shape]) + except TypeError: + raise TypeError(f"shape must be an int or a sequence of ints; got {shape!r}") from None + nbytes = dtype.itemsize + for dim in shape: + if dim < 0: + raise ValueError("negative dimensions are not allowed") + nbytes *= dim + if nbytes > PY_SSIZE_T_MAX: + raise ValueError("array is too big") + dims = np.array(shape, dtype=np.intp) + ptr = arenas[k].malloc(nbytes or 1) # NumPy never allocates 0 bytes either + if ptr == NULL: + raise MemoryError(f"Unable to allocate {nbytes} bytes") + Py_INCREF(dtype) + try: + array = PyArray_NewFromDescr( + ndarray, + dtype, + len(shape), + PyArray_DATA(dims), + NULL, + ptr, + NPY_ARRAY_WRITEABLE | (NPY_ARRAY_F_CONTIGUOUS if order == "F" else 0), + NULL, + ) + except BaseException: + arenas[k].free(ptr) + raise + own_data(array, handler) + return array + + +@contextmanager +def give_buffer(array, ctype="void*", *, copy=None, arena=None): + """Hand the data of ``array`` to a GraphBLAS function that takes ownership of it. + + Yields ``(ptr, nbytes, arena)``: ``ptr`` is a new ``ctype *`` that points to the data, + to pass to, e.g., ``GxB_Matrix_pack_CSR`` (with ``nbytes`` as the size) or to + ``GxB_Vector_load`` (with handling ``GrB_DEFAULT + arena``). GraphBLAS sets ``*ptr`` + to NULL when it takes ownership; then, on exit, the array handed over becomes a + read-only view of data it no longer owns. Otherwise (e.g., the call failed) nothing + changes. + + copy : bool, optional + None (default): hand over the data of ``array`` itself if GraphBLAS can own it + (see ``can_unclaim_buffer``), else a copy. True: always hand over a copy, leaving + ``array`` unchanged. False: never copy; raise ValueError if GraphBLAS can't own it. + arena : int, optional + The GraphBLAS arena that will own the data (default: the global data arena). + + An array is handed over only once: to give the same array as two arguments of one + call, nest two ``give_buffer`` and the second gets a copy. Giving one array from two + threads at once is a race, like any other change to an array. + + Examples + -------- + >>> import numpy as np + >>> from suitesparse_graphblas import check_status, ffi, lib, vector + >>> from suitesparse_graphblas.utils import give_buffer + >>> v = vector.vector_new(lib.GrB_INT64) + >>> values = np.arange(3, dtype=np.int64) + >>> with give_buffer(values) as (X, nbytes, arena): + ... info = lib.GxB_Vector_load( + ... v[0], X, lib.GrB_INT64, values.size, nbytes, lib.GrB_DEFAULT + arena, ffi.NULL + ... ) + ... check_status(v, info) + >>> vector.vector_nvals(v), values.flags.owndata + (3, False) + """ + cdef int k = _resolve_arena(arena) + cdef ndarray buf + if copy is not None and not isinstance(copy, bool): + raise TypeError(f"copy must be None, True, or False; got {copy!r}") + handler = _handler(k) + array = np.asarray(array) + if array.dtype.hasobject: + raise TypeError("GraphBLAS cannot own arrays that hold Python objects") + why_not = None if copy else _why_not_ownable(array, handler) + if copy is False and why_not is not None: + raise ValueError( + f"GraphBLAS cannot take ownership of the data of this array without copying: {why_not}" + ) + if copy or why_not is not None: + order = "F" if array.flags.f_contiguous and not array.flags.c_contiguous else "C" + buf = empty(array.shape, array.dtype, order, k) + np.copyto(buf, array, casting="no") + else: + buf = array + ptr = _ffi.new(f"{ctype}*", _ffi.cast(ctype, PyArray_DATA(buf))) + # `buf` stops owning its data for now, so that giving the same array again copies it + PyArray_CLEARFLAGS(buf, NPY_ARRAY_OWNDATA) + try: + yield ptr, buf.nbytes, k + finally: + if ptr[0] == _ffi.NULL: # GraphBLAS owns the data now + PyArray_CLEARFLAGS(buf, NPY_ARRAY_WRITEABLE) + else: + PyArray_ENABLEFLAGS(buf, NPY_ARRAY_OWNDATA) diff --git a/tests/test_package.py b/tests/test_package.py deleted file mode 100644 index ce0f9a7..0000000 --- a/tests/test_package.py +++ /dev/null @@ -1,4 +0,0 @@ -from suitesparse.graphblas import lib, ffi - -def test_matrix_existence(): - assert hasattr(lib, "GrB_Matrix_new")