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..efbe9a5 --- /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 = + suitesparse_graphblas/io/binary.py:C408, + suitesparse_graphblas/tests/test_io.py:E721, diff --git a/.github/dependabot.yml b/.github/dependabot.yml new file mode 100644 index 0000000..b18fd29 --- /dev/null +++ b/.github/dependabot.yml @@ -0,0 +1,6 @@ +version: 2 +updates: + - package-ecosystem: 'github-actions' + directory: '/' + schedule: + interval: 'weekly' diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml new file mode 100644 index 0000000..4140839 --- /dev/null +++ b/.github/workflows/lint.yml @@ -0,0 +1,21 @@ +name: Lint via pre-commit + +on: + pull_request: + push: + branches-ignore: + - main + +permissions: + contents: read + +jobs: + pre-commit: + name: pre-commit-hooks + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: "3.10" + - uses: pre-commit/action@v3.0.1 diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..508d4a7 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,75 @@ +name: Test + +on: + push: + branches: [ main ] + pull_request: + +jobs: + test: + runs-on: ${{ matrix.os }} + defaults: + run: + shell: bash -l {0} + strategy: + fail-fast: false + matrix: + os: ["ubuntu-latest", "macos-latest", "windows-latest"] + source: ["conda-forge"] + # os: ["ubuntu-latest"] + # source: ["source"] + python-version: ["3.9", "3.10", "3.11", "3.12", "3.13"] + steps: + - name: Checkout + uses: actions/checkout@v4 + with: + fetch-depth: 0 + - name: Conda + uses: conda-incubator/setup-miniconda@v3 + with: + auto-update-conda: true + python-version: ${{ matrix.python-version }} + environment-file: continuous_integration/environment.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: Test + env: + CYTHON_COVERAGE: true + run: | + pytest -s -k test_print_jit_config + coverage run --branch -m pytest + coverage run -a --branch suitesparse_graphblas/tests/test_initialize.py + - name: create_headers.py check + if: (! contains(matrix.os, 'windows')) + run: | + coverage run -a --branch 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..153f1a7 --- /dev/null +++ b/.github/workflows/update_graphblas.yml @@ -0,0 +1,61 @@ +# 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 + +# In addition to permissions below, 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 + +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 + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - uses: actions/setup-python@v5 + 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@v7 + 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..20434c0 --- /dev/null +++ b/.github/workflows/wheels.yml @@ -0,0 +1,237 @@ +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: + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +permissions: + # For PyPI Trusted Publisher + id-token: write + +jobs: + build_sdist: + name: Build SDist + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + - name: Build SDist + run: pipx run build --sdist + + - name: Check metadata + run: pipx run twine check dist/* + + - uses: actions/upload-artifact@v4 + 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" + + # Linux x86 manylinux + - os: ubuntu-latest + cibw_archs: "x86_64" + # Python 3.12 wheel requires libffi-devel to be installed. manylinux container uses yum + cibw_before_build_linux: "yum install -y libffi-devel" + # skip musllinux + cibw_skip: "*musl*" + + # Linux x86 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), PyPy (no musl numpy wheels), CPython 3.8 (no musl numpy wheels) + cibw_skip: "*many* pp* cp38*" + + # Linux aarch64 + # Separate runner because this requires emulation (only x86 runners are available) and is very slow. + - os: ubuntu-latest + cibw_archs: "aarch64" + # numpy wheels not available for aarch64 PyPy or musllinux + cibw_skip: "pp* *musl*" + + # macOS x86 + # Note: keep as old as possible as due to libomp this will be the oldest supported macOS version. + - os: macos-13 + cibw_archs: "x86_64" + + # macOS Apple Silicon + # Note: keep as old as possible as due to libomp this will be the oldest supported macOS version. + - os: macos-14 + cibw_archs: "arm64" + + steps: + - uses: actions/checkout@v4 + with: + fetch-depth: 0 + + # aarch64 Linux builds are cross-compiled on x86 runners using emulation + # see https://cibuildwheel.readthedocs.io/en/stable/faq/#emulation + - name: Setup QEMU (for aarch64) + if: matrix.cibw_archs == 'aarch64' + uses: docker/setup-qemu-action@v3 + with: + platforms: arm64 + + - name: Setup env (for aarch64) + if: matrix.cibw_archs == 'aarch64' + # Ask suitesparse.sh to compile faster by optimizing fewer types. Otherwise, the build takes too long to finish + # in 6 hour limit. + run: | + echo "SUITESPARSE_FAST_BUILD=1" >> $GITHUB_ENV + + - 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@v2.22 + with: + output-dir: wheelhouse + env: + # very verbose + CIBW_BUILD_VERBOSITY: 3 + + # Build SuiteSparse + CIBW_BEFORE_ALL: bash suitesparse.sh ${{ env.GB_VERSION_REF }} + + CIBW_BEFORE_BUILD_LINUX: ${{ matrix.cibw_before_build_linux }} + + CIBW_ENVIRONMENT_PASS_LINUX: SUITESPARSE_FAST_BUILD 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 }} + + # as of writing numpy does not support pypy 3.10 + CIBW_SKIP: "${{ matrix.cibw_skip }} pp310*" + + # 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 includes tools for this for Linux and macOS, and they recommend delvewheel for Windows. + # Note: Currently using a workaround: --no-mangle instead of stripping graphblas.dll + # see https://github.com/adang1345/delvewheel/issues/33 + CIBW_BEFORE_BUILD_WINDOWS: "pip install delvewheel" + 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 + CIBW_TEST_COMMAND: "pytest --pyargs suitesparse_graphblas -s -k test_print_jit_config && pytest -v --pyargs suitesparse_graphblas" + + CIBW_TEST_SKIP: ${{ matrix.cibw_test_skip }} + + - uses: actions/upload-artifact@v4 + with: + name: wheels-${{ matrix.os }}-${{ matrix.cibw_archs }}${{ matrix.arch_note}} + path: wheelhouse/*.whl + if-no-files-found: error + + + upload_all: + name: Upload to PyPI + needs: [build_wheels, build_sdist] + runs-on: ubuntu-latest + # only upload releases 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 != 'No Upload')) + + steps: + - uses: actions/setup-python@v5 + with: + python-version: "3.x" + + - uses: actions/download-artifact@v4 + with: + path: dist + merge-multiple: true + + # Upload to PyPI + - uses: pypa/gh-action-pypi-publish@release/v1 + name: Upload to PyPI + if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && github.event.inputs.upload_dest == 'PyPI') + with: + # PyPI does not allow replacing a file. Without this flag the entire action fails if even a single duplicate exists. + skip-existing: true + verbose: true + password: ${{ secrets.PYPI_TOKEN }} + + # Upload to Test PyPI + - uses: pypa/gh-action-pypi-publish@release/v1 + name: Upload to Test PyPI + if: github.event_name == 'workflow_dispatch' && github.event.inputs.upload_dest == 'Test PyPI' + with: + # PyPI does not allow replacing a file. Without this flag the entire action fails if even a single duplicate exists. + skip-existing: true + verbose: true + repository-url: https://test.pypi.org/legacy/ diff --git a/.gitignore b/.gitignore index 2b09537..e382cda 100644 --- a/.gitignore +++ b/.gitignore @@ -4,7 +4,9 @@ __pycache__/ *$py.class # C extensions +*.c *.so +*.dll # Distribution / packaging .Python @@ -26,6 +28,10 @@ share/python-wheels/ .installed.cfg *.egg MANIFEST +wheelhouse + +# Wheel building stuff +GraphBLAS-*/ # PyInstaller # Usually these files are written by a python script from a template diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000..2a8fd94 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,89 @@ +# 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-illegal-windows-names + - id: check-merge-conflict + - id: check-ast + - id: check-toml + - id: check-yaml + # - id: check-executables-have-shebangs + - 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 + - repo: https://github.com/abravalheri/validate-pyproject + rev: v0.24.1 + hooks: + - id: validate-pyproject + name: Validate pyproject.toml + - repo: https://github.com/PyCQA/autoflake + rev: v2.3.1 + hooks: + - id: autoflake + args: [--in-place] + - repo: https://github.com/pycqa/isort + rev: 6.0.1 + hooks: + - id: isort + - repo: https://github.com/asottile/pyupgrade + rev: v3.20.0 + hooks: + - id: pyupgrade + args: [--py39-plus] + - repo: https://github.com/psf/black-pre-commit-mirror + rev: 25.1.0 + hooks: + - id: black + - repo: https://github.com/PyCQA/flake8 + rev: 7.3.0 + hooks: + - id: flake8 + args: ["--config=.flake8"] + additional_dependencies: &flake8_dependencies + # These versions need updated manually + - flake8==7.3.0 + - flake8-comprehensions==3.17.0 + - flake8-bugbear==24.12.12 + # - flake8-simplify==0.21.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: "4.2" + # hooks: + # - id: pyroma + # args: [-n, "10", .] + - repo: https://github.com/python-jsonschema/check-jsonschema + rev: 0.33.3 + hooks: + - id: check-dependabot + - id: check-github-workflows + - 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/Dockerfile b/Dockerfile new file mode 100644 index 0000000..fa101e5 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,47 @@ +ARG BASE_CONTAINER=python:3.9-slim-buster +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 + +WORKDIR /build +RUN git clone https://github.com/eliben/pycparser.git --depth 1 + +WORKDIR /build/GraphBLAS/build +RUN git clone https://github.com/DrTimothyAldenDavis/GraphBLAS.git --depth 1 --branch ${SUITESPARSE} \ + && cd GraphBLAS/build \ + && cmake .. -DCMAKE_INSTALL_PREFIX=/usr -DGBCOMPACT=${COMPACT} \ + && make -j$(nproc) \ + && make install + +FROM ${BASE_CONTAINER} as psg +ARG SUITESPARSE +ARG VERSION +ENV PYTHONUNBUFFERED 1 + +COPY --from=suitesparse /usr/include/GraphBLAS.h /usr/local/include/ +COPY --from=suitesparse /usr/lib/x86_64-linux-gnu/libgraphblas* /usr/lib/x86_64-linux-gnu/ +COPY --from=suitesparse /build/pycparser/utils/fake_libc_include/* /usr/local/lib/python3.9/site-packages/pycparser/utils/fake_libc_include/ + +RUN apt-get update && apt-get install -yq build-essential git +RUN pip3 install numpy cffi pytest cython + +RUN mkdir -p /psg +ADD . /psg + +WORKDIR /psg +RUN git tag ${VERSION} && \ + python3 suitesparse_graphblas/create_headers.py && \ + python3 setup.py install && \ + 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* /usr/lib/x86_64-linux-gnu/ +COPY --from=suitesparse /usr/lib/x86_64-linux-gnu/libgomp* /usr/lib/x86_64-linux-gnu/ +COPY --from=psg /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages diff --git a/GB_VERSION.txt b/GB_VERSION.txt new file mode 100644 index 0000000..2312799 --- /dev/null +++ b/GB_VERSION.txt @@ -0,0 +1 @@ +10.1.1 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..2d15f15 100644 --- a/README.md +++ b/README.md @@ -1,8 +1,44 @@ # 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 +``` + +## 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..7548102 --- /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", None) + +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..31e2b25 --- /dev/null +++ b/docker_build.sh @@ -0,0 +1,49 @@ +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 + git clone --branch $BRANCH https://github.com/GraphBLAS/python-suitesparse-graphblas.git + cd python-suitesparse-graphblas +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..3a47125 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,127 @@ +[build-system] +build-backend = "setuptools.build_meta" +requires = [ + # setuptools<74 until PyPy vendors cffi 1.15.1 + "setuptools >=64, <74", + "setuptools-git-versioning", + "wheel", + "cffi>=1.11", + "cython", + "numpy>=2.0", +] + +[project] +name = "suitesparse-graphblas" +dynamic = ["version"] +description = "SuiteSparse:GraphBLAS Python bindings." +readme = "README.md" +requires-python = ">=3.9" +license = {file = "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", + "License :: OSI Approved :: Apache Software License", + "Operating System :: MacOS :: MacOS X", + "Operating System :: POSIX :: Linux", + "Operating System :: Microsoft :: Windows", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + "Programming Language :: Python :: 3.13", + "Programming Language :: Python :: 3 :: Only", + "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.23", +] +[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", +] + +[tool.setuptools] +packages = [ + 'suitesparse_graphblas', + 'suitesparse_graphblas.tests', + 'suitesparse_graphblas.io', +] + +[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 = ["py39", "py310", "py311", "py312", "py313"] + +[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] +testpaths = ["suitesparse_graphblas/tests"] diff --git a/setup.py b/setup.py index 78ac159..860cd3a 100644 --- a/setup.py +++ b/setup.py @@ -1,14 +1,67 @@ -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")] + +# /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..f804f40 --- /dev/null +++ b/suitesparse.sh @@ -0,0 +1,157 @@ +#!/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/([0-9]*\.[0-9]*\.[0-9]*\.beta[0-9]*).*$ ]]; then + 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=() +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") + export LDFLAGS="-L$(brew --prefix libomp)/lib" + + 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 + +if [ -n "${GRAPHBLAS_PREFIX}" ]; then + echo "GRAPHBLAS_PREFIX=${GRAPHBLAS_PREFIX}" + cmake_params+=(-DCMAKE_INSTALL_PREFIX="${GRAPHBLAS_PREFIX}") +fi + +curl -L https://github.com/DrTimothyAldenDavis/GraphBLAS/archive/refs/tags/v${VERSION}.tar.gz | tar xzf - +cd GraphBLAS-${VERSION}/build + +# 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). +# 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. + +# 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. + + 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 + + # Setting COMPACT probably makes setting config in GB_control.h above unnecessary + cmake_params+=(-DCOMPACT=1) + # Also no JIT for the fastest possible build + cmake_params+=(-DNJIT=1) + # Disable all Source/Generated2 kernels. For workflow development only. + cmake_params+=(-DCMAKE_CUDA_DEV=1) +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 `-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. + cmake_params+=(-DJITINIT=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" ]; then + SUDO=sudo +else + SUDO="" +fi + +cmake .. -DCMAKE_BUILD_TYPE=Release -G 'Unix Makefiles' "${cmake_params[@]}" +make -j$NPROC +$SUDO make install + +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..72838b0 --- /dev/null +++ b/suitesparse_graphblas/__init__.py @@ -0,0 +1,305 @@ +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 + +# 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 to use. 'numpy' uses numpy's + allocators, which makes it safe to perform zero-copy to and from numpy, + and allows Python to track memory usage via tracemalloc (if enabled). + 'c' uses the default allocators. 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": + utils.call_gxb_init(ffi, lib, blocking) + elif memory_manager == "c": + lib.GrB_init(blocking) + else: + raise ValueError(f'memory_manager argument must be "numpy" or "c"; got: {memory_manager!r}') + # 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, +} + + +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.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.nvals(A) + [ GrB_Matrix_nvals + 1.91e-06 sec ] + >>> burble.disable() + + Example as a context manager: + + >>> with burble(): + >>> n = 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() diff --git a/suitesparse/graphblas/create_headers.py b/suitesparse_graphblas/create_headers.py similarity index 79% rename from suitesparse/graphblas/create_headers.py rename to suitesparse_graphblas/create_headers.py index 74a5b8a..fbfbd0f 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,7 @@ def groupby(index, seq): "GRB_SUBVERSION", "GxB_NTHREADS", "GxB_CHUNK", - "GxB_GPU_CONTROL", - "GxB_GPU_CHUNK", + "GxB_GPU_ID", "GxB_HYPERSPARSE", "GxB_SPARSE", "GxB_BITMAP", @@ -289,6 +293,14 @@ 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", } CHAR_DEFINES = { @@ -301,18 +313,37 @@ 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", } +IGNORE_LINES = { + "GxB_cuda_calloc", + "GxB_cuda_malloc", + "GxB_cuda_free", +} +IGNORE_ENUMS = { + "memory_order", + "RMM_MODE", +} + class VisitEnumTypedef(c_generator.CGenerator): def __init__(self, *args, **kwargs): @@ -326,6 +357,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 +385,22 @@ 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 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 +419,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 +429,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 +440,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,16 +615,24 @@ 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 + ): raise ValueError(generator.visit(node)) if node.name in DEPRECATED: return @@ -562,13 +644,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 +664,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 +676,8 @@ def handle_function_node(node): "finalize": "core", "init": "core", "wait": "core", + "deserialize": "core", + "Serialized": "core", # Added in version 9 }[group] return { "name": node.name, @@ -600,9 +692,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 +749,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 +821,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 +838,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 +855,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 +867,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 +881,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 +926,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..e69de29 diff --git a/suitesparse_graphblas/io/binary.py b/suitesparse_graphblas/io/binary.py new file mode 100644 index 0000000..0248e7b --- /dev/null +++ b/suitesparse_graphblas/io/binary.py @@ -0,0 +1,554 @@ +from ctypes.util import find_library +from pathlib import Path + +from cffi import FFI + +from suitesparse_graphblas import __version__, check_status, ffi, lib, matrix + +stdffi = FFI() +stdffi.cdef( + """ +void *malloc(size_t size); +""" +) +stdlib = stdffi.dlopen(find_library("c")) + +# When "packing" a matrix the owner of the memory buffer is transfered +# to SuiteSparse, which then becomes responsible for freeing it. cffi +# wisely does not allow you to do this without declaring and calling +# malloc directly. When SuiteSparse moves over to a more formal +# memory manager with the cuda work, this will likely change and have +# to be replaceable with a allocator common to numpy, cuda, and here. +# Maybe PyDataMem_NEW? + + +def readinto_new_buffer(f, typ, size, allocator=stdlib.malloc): + buff = ffi.cast(typ, allocator(size)) + f.readinto(ffi.buffer(buff, size)) + return buff + + +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): + 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.nrows(A) + ncols[0] = matrix.ncols(A) + nvals[0] = matrix.nvals(A) + matrix_type[0] = matrix.type(A) + + check_status(A, lib.GxB_Type_size(typesize, matrix_type[0])) + typecode[0] = _ss_typecodes[matrix_type[0]] + + format[0] = matrix.format(A) + hyper_switch[0] = matrix.hyper_switch(A) + bitmap_switch[0] = matrix.bitmap_switch(A) + sparsity_status[0] = matrix.sparsity_status(A) + sparsity_control[0] = 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") + + 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)) + + 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 hever happen") + + +def binread(filename, opener=Path.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"))) + is_jumbled = ffi.new("bool*", 0) + + 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]] + + 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*") + + if is_hyper: + Ap_size[0] = (nvec[0] + 1) * Isize + Ah_size[0] = nvec[0] * Isize + Ai_size[0] = nvals[0] * Isize + Ax_size[0] = nvals[0] * typesize[0] + + Ap[0] = readinto_new_buffer(f, "GrB_Index*", Ap_size[0]) + Ah[0] = readinto_new_buffer(f, "GrB_Index*", Ah_size[0]) + Ai[0] = readinto_new_buffer(f, "GrB_Index*", Ai_size[0]) + elif is_sparse: + Ap_size[0] = (nvec[0] + 1) * Isize + Ai_size[0] = nvals[0] * Isize + Ax_size[0] = nvals[0] * typesize[0] + Ap[0] = readinto_new_buffer(f, "GrB_Index*", Ap_size[0]) + Ai[0] = readinto_new_buffer(f, "GrB_Index*", Ai_size[0]) + elif is_bitmap: + Ab_size[0] = nrows[0] * ncols[0] * ffi.sizeof("int8_t") + Ax_size[0] = nrows[0] * ncols[0] * typesize[0] + Ab[0] = readinto_new_buffer(f, "int8_t*", Ab_size[0]) + elif is_full: + Ax_size[0] = nrows[0] * ncols[0] * typesize[0] + + Ax[0] = readinto_new_buffer(f, "uint8_t*", typesize[0] if is_iso[0] else Ax_size[0]) + + A = matrix.new(atype, nrows[0], ncols[0]) + + 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("Unknown format {format[0]}") + + matrix.set_sparsity_control(A, sparsity_control[0]) + matrix.set_hyper_switch(A, hyper_switch[0]) + matrix.set_bitmap_switch(A, bitmap_switch[0]) + return A diff --git a/suitesparse_graphblas/io/serialize.py b/suitesparse_graphblas/io/serialize.py new file mode 100644 index 0000000..fcc7804 --- /dev/null +++ b/suitesparse_graphblas/io/serialize.py @@ -0,0 +1,143 @@ +import numpy as np + +from suitesparse_graphblas import check_status, ffi, lib +from suitesparse_graphblas.utils import claim_buffer + + +def free_desc(desc): + """Free a descriptor.""" + check_status(desc, lib.GrB_Descriptor_free(desc)) + + +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 pointer to a GrB_Descriptor. + """ + if nthreads is None and (compression is None or compression == lib.GxB_COMPRESSION_DEFAULT): + return None + desc = ffi.new("GrB_Descriptor*") + check_status(desc, lib.GrB_Descriptor_new(desc)) + desc = ffi.gc(desc, free_desc) + if nthreads is not None: + check_status( + desc, + lib.GxB_Desc_set_INT32(desc[0], 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[0], 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*") + check_status( + A, lib.GxB_Matrix_serialize(data_ptr, size_ptr, A[0], ffi.NULL if desc is None else desc[0]) + ) + return claim_buffer(ffi, data_ptr[0], size_ptr[0], np.dtype(np.uint8)) + + +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*") + check_status( + v, lib.GxB_Vector_serialize(data_ptr, size_ptr, v[0], ffi.NULL if desc is None else desc[0]) + ) + return claim_buffer(ffi, data_ptr[0], size_ptr[0], np.dtype(np.uint8)) + + +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.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[0], + ), + ) + if free: + if callable(free): + return ffi.gc(A, free) + return ffi.gc(A, 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.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[0], + ), + ) + if free: + if callable(free): + return ffi.gc(v, free) + return ffi.gc(v, vector.free) + return v + + +from suitesparse_graphblas import matrix, vector # noqa: E402 isort:skip diff --git a/suitesparse_graphblas/matrix.py b/suitesparse_graphblas/matrix.py new file mode 100644 index 0000000..5efa15d --- /dev/null +++ b/suitesparse_graphblas/matrix.py @@ -0,0 +1,202 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .io.serialize import deserialize_matrix as deserialize # noqa: F401 +from .io.serialize import serialize_matrix as serialize # noqa: F401 + + +def free(A): + """Free a matrix.""" + check_status(A, lib.GrB_Matrix_free(A)) + + +def new(T, nrows=lib.GxB_INDEX_MAX, ncols=lib.GxB_INDEX_MAX, *, free=free): + """Create a new `GrB_Matrix` of type `T` and initialize it. The + following example creates an eight bit unsigned 2x2 matrix: + + >>> A = new(lib.GrB_UINT8, 2, 2) + >>> shape(A) + (2, 2) + + The default value for `nrows` and `ncols` is `lib.GxB_INDEX_MAX` + which creates a Matrix with maximal bounds: + + >>> A = new(lib.GrB_UINT8) + >>> 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.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 type(A): + """Return the GraphBLAS type of the vector. + + >>> A = new(lib.GrB_UINT8) + >>> 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 nrows(A): + """Return the number of rows in the matrix. + + >>> A = new(lib.GrB_UINT8, 2, 3) + >>> nrows(A) + 2 + + """ + n = ffi.new("GrB_Index*") + check_status(A, lib.GrB_Matrix_nrows(n, A[0])) + return n[0] + + +def ncols(A): + """Return the number of columns in the matrix. + + >>> A = new(lib.GrB_UINT8, 2, 3) + >>> ncols(A) + 3 + + """ + n = ffi.new("GrB_Index*") + check_status(A, lib.GrB_Matrix_ncols(n, A[0])) + return n[0] + + +def nvals(A): + """Return the number of stored elements in the matrix. + + >>> A = new(lib.GrB_UINT8, 2, 3) + >>> nvals(A) + 0 + + """ + n = ffi.new("GrB_Index*") + check_status(A, lib.GrB_Matrix_nvals(n, A[0])) + return n[0] + + +def shape(A): + """Return the shape of the matrix as a two tuple `(nrows, ncols)` + + >>> A = new(lib.GrB_UINT8, 2, 2) + >>> shape(A) + (2, 2) + + """ + return (nrows(A), ncols(A)) + + +def format(A): + """Return the format of the matrix. + + >>> A = new(lib.GrB_UINT8, 2, 2) + >>> 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 set_format(A, format): + """Set the format of the matrix. + + >>> A = new(lib.GrB_UINT8, 2, 2) + >>> set_format(A, lib.GxB_BY_COL) + >>> 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 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 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 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 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 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 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 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 set_bool(A, value, i, j): + """Set a boolean value to the matrix at row `i` column `j`. + + >>> A = new(lib.GrB_BOOL, 3, 3) + >>> set_bool(A, True, 2, 2) + >>> bool(A, 2, 2) == True + True + + """ + check_status(A, lib.GrB_Matrix_setElement_BOOL(A[0], value, i, j)) + + +def bool(A, i, j): + """Get a boolean value from the matrix at row `i` column `j`. + + >>> A = new(lib.GrB_BOOL, 3, 3) + >>> set_bool(A, True, 2, 2) + >>> 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] diff --git a/suitesparse_graphblas/scalar.py b/suitesparse_graphblas/scalar.py new file mode 100644 index 0000000..c0d5747 --- /dev/null +++ b/suitesparse_graphblas/scalar.py @@ -0,0 +1,65 @@ +from suitesparse_graphblas import check_status, exceptions, ffi, lib + + +def free(v): + """Free a scalar.""" + check_status(v, lib.GxB_Scalar_free(v)) + + +def new(T, *, free=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.free()`. If `free` is None then + there is no automatic garbage collection and it is up to the user + to free the scalar. + + >>> S = 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 type(s): + """Return the GraphBLAS type of the scalar. + + >>> S = new(lib.GrB_UINT8) + >>> type(S) == lib.GrB_UINT8 + True + + """ + T = ffi.new("GrB_Type*") + check_status(s, lib.GxB_Scalar_type(T, s[0])) + return T[0] + + +def set_bool(s, value): + """Set a boolean value to the scalar. + + >>> s = new(lib.GrB_BOOL) + >>> set_bool(s, True) + >>> bool(s) == True + True + + """ + check_status(s, lib.GxB_Scalar_setElement_BOOL(s[0], value)) + + +def bool(s): + """Get a boolean value from the scalar. + + >>> s = new(lib.GrB_BOOL) + >>> set_bool(s, True) + >>> 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] 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..f0a4b44 --- /dev/null +++ b/suitesparse_graphblas/suitesparse_graphblas.h @@ -0,0 +1,3787 @@ +/* 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 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; + uint32_t u32_future[14]; + 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, + GxB_NONBLOCKING_GPU = 7099, + GxB_BLOCKING_GPU = 7098 +} 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_GPU_ID = 7088 +} 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_GLOBAL_NTHREADS = 7086, + GxB_GLOBAL_CHUNK = 7087, + GxB_GLOBAL_GPU_ID = 7088, + 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_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_handle, GrB_Matrix A); +GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size_handle, 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_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); + +/* 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_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_deserialize_type_name(char *, const void *, uint64_t); +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 *)); + +/* 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); + +/* 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_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_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_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_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); +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_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_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_handle, GrB_Matrix A, 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_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_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_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); + +/* scalar */ +GrB_Info GxB_BinaryOp_new_IndexOp(GrB_BinaryOp *binop, GxB_IndexBinaryOp idxbinop, GrB_Scalar theta); +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_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_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_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); + +/* 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_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_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_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_size, int handling, const GrB_Descriptor desc); +GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); +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_handle, GrB_Vector u, 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_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_size, 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_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_ID ... +#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_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 ... +#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..86a6798 --- /dev/null +++ b/suitesparse_graphblas/suitesparse_graphblas_no_complex.h @@ -0,0 +1,3553 @@ +/* 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 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; + uint32_t u32_future[14]; + 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, + GxB_NONBLOCKING_GPU = 7099, + GxB_BLOCKING_GPU = 7098 +} 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_GPU_ID = 7088 +} 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_GLOBAL_NTHREADS = 7086, + GxB_GLOBAL_CHUNK = 7087, + GxB_GLOBAL_GPU_ID = 7088, + 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_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_handle, GrB_Matrix A); +GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size_handle, 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_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); + +/* 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_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_deserialize_type_name(char *, const void *, uint64_t); +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 *)); + +/* 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); + +/* 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_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_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_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_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); +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_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_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_handle, GrB_Matrix A, const GrB_Descriptor desc); +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_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_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); + +/* scalar */ +GrB_Info GxB_BinaryOp_new_IndexOp(GrB_BinaryOp *binop, GxB_IndexBinaryOp idxbinop, GrB_Scalar theta); +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_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_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_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); + +/* 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_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_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_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_size, int handling, const GrB_Descriptor desc); +GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); +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_handle, GrB_Vector u, const GrB_Descriptor desc); +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_size, 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_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_ID ... +#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_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 ... +#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/conftest.py b/suitesparse_graphblas/tests/conftest.py new file mode 100644 index 0000000..b6c5ead --- /dev/null +++ b/suitesparse_graphblas/tests/conftest.py @@ -0,0 +1,8 @@ +import pytest + +from suitesparse_graphblas import initialize + + +@pytest.fixture(scope="session", autouse=True) +def intialize_suitesparse_graphblas(): + initialize() diff --git a/suitesparse_graphblas/tests/test_doctest.py b/suitesparse_graphblas/tests/test_doctest.py new file mode 100644 index 0000000..68b9444 --- /dev/null +++ b/suitesparse_graphblas/tests/test_doctest.py @@ -0,0 +1,11 @@ +def test_run_doctests(): + import doctest + + from suitesparse_graphblas import matrix, scalar, vector + + for mod in ( + matrix, + vector, + scalar, + ): + doctest.testmod(mod, optionflags=doctest.ELLIPSIS, raise_on_error=True) 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..dcdf857 --- /dev/null +++ b/suitesparse_graphblas/tests/test_io.py @@ -0,0 +1,198 @@ +import bz2 +import gzip +import lzma +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, +) + +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.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.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.nvals(A) == matrix.nvals(B) == 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.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.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.nvals(v) == vector.nvals(w) == 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): + for opener in (Path.open, gzip.open, bz2.open, lzma.open): + 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.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.set_sparsity_control(A, sparsity) + 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.type(A) == matrix.type(B) + assert matrix.nrows(A) == matrix.nrows(B) + assert matrix.ncols(A) == matrix.ncols(B) + assert matrix.hyper_switch(A) == matrix.hyper_switch(B) + assert matrix.bitmap_switch(A) == matrix.bitmap_switch(B) + # assert matrix.sparsity_control(A) == matrix.sparsity_control(B) + + C = 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.nvals(A) == matrix.nvals(B) == 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] 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_package.py b/suitesparse_graphblas/tests/test_package.py new file mode 100644 index 0000000..77086a6 --- /dev/null +++ b/suitesparse_graphblas/tests/test_package.py @@ -0,0 +1,14 @@ +import suitesparse_graphblas +from suitesparse_graphblas import ffi, lib # noqa: F401 + + +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] 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..69a279e --- /dev/null +++ b/suitesparse_graphblas/utils.pxd @@ -0,0 +1,40 @@ +from libc.stdint cimport uint64_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) + # 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 + +ctypedef uint64_t (*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 *), +) + +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) + +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 +) + +cpdef unclaim_buffer(ndarray array) diff --git a/suitesparse_graphblas/utils.pyx b/suitesparse_graphblas/utils.pyx new file mode 100644 index 0000000..95d2f1b --- /dev/null +++ b/suitesparse_graphblas/utils.pyx @@ -0,0 +1,75 @@ +import numpy as np +from cpython.ref cimport Py_INCREF +from libc.stdint cimport uintptr_t +from numpy cimport NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_OWNDATA, NPY_ARRAY_WRITEABLE +from numpy cimport dtype as dtype_t +from numpy cimport import_array, ndarray, npy_intp + +import_array() + +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): + cdef: + npy_intp dims = size + uintptr_t ptr = int(ffi.cast("uintptr_t", cdata)) + ndarray array + Py_INCREF(dtype) + array = PyArray_NewFromDescr( + ndarray, dtype, 1, &dims, NULL, ptr, NPY_ARRAY_WRITEABLE, NULL + ) + PyArray_ENABLEFLAGS(array, NPY_ARRAY_OWNDATA) + 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 +): + cdef: + size_t size = nrows * ncols + ndarray array + uintptr_t ptr + npy_intp dims[2] + int flags = NPY_ARRAY_WRITEABLE + if cdata_size == size: + ptr = int(ffi.cast("uintptr_t", cdata)) + 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 + ) + PyArray_ENABLEFLAGS(array, NPY_ARRAY_OWNDATA) + elif cdata_size > size: # pragma: no cover + array = claim_buffer(ffi, cdata, cdata_size, dtype) + 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 unclaim_buffer(ndarray array): + PyArray_CLEARFLAGS(array, NPY_ARRAY_OWNDATA | NPY_ARRAY_WRITEABLE) diff --git a/suitesparse_graphblas/vector.py b/suitesparse_graphblas/vector.py new file mode 100644 index 0000000..a6a15c6 --- /dev/null +++ b/suitesparse_graphblas/vector.py @@ -0,0 +1,103 @@ +from suitesparse_graphblas import check_status, ffi, lib + +from .io.serialize import deserialize_vector as deserialize # noqa: F401 +from .io.serialize import serialize_vector as serialize # noqa: F401 + + +def free(v): + """Free a vector.""" + check_status(v, lib.GrB_Vector_free(v)) + + +def new(T, size=lib.GxB_INDEX_MAX, *, free=free): + """Create a new `GrB_Vector` of type `T` and initialize it. + + >>> A = new(lib.GrB_UINT8, 2) + >>> size(A) + 2 + + The default `size` is `lib.GxB_INDEX_MAX`. + + >>> A = new(lib.GrB_UINT8) + >>> size(A) == lib.GxB_INDEX_MAX + True + + The `free` argument is called when the object is garbage + collected, the default is `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 type(v): + """Return the GraphBLAS type of the vector. + + >>> v = new(lib.GrB_UINT8, 2) + >>> 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 size(v): + """Return the size of the vector. + + >>> v = new(lib.GrB_UINT8, 2) + >>> size(v) == 2 + True + + """ + n = ffi.new("GrB_Index*") + check_status(v, lib.GrB_Vector_size(n, v[0])) + return n[0] + + +def nvals(v): + """Return the number of stored elements in the vector. + + >>> v = new(lib.GrB_BOOL, 2) + >>> nvals(v) + 0 + >>> set_bool(v, True, 1) + >>> nvals(v) + 1 + + """ + n = ffi.new("GrB_Index*") + check_status(v, lib.GrB_Vector_nvals(n, v[0])) + return n[0] + + +def set_bool(v, value, i): + """Set a boolean value to the vector at position `i`. + + >>> v = new(lib.GrB_BOOL, 3) + >>> set_bool(v, True, 2) + >>> bool(v, 2) == True + True + + """ + check_status(v, lib.GrB_Vector_setElement_BOOL(v[0], value, i)) + + +def bool(v, i): + """Get a boolean value from the vector at position `i`. + + >>> v = new(lib.GrB_BOOL, 3) + >>> set_bool(v, True, 2) + >>> bool(v, 2) == True + True + + """ + value = ffi.new("bool*") + check_status(v, lib.GrB_Vector_extractElement_BOOL(value, v[0], i)) + return value[0] 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")