pax_global_header00006660000000000000000000000064143524000240014504gustar00rootroot0000000000000052 comment=d36c2cf53d75587b20ddf11e67f48637cd530aaa python-suitesparse-graphblas-7.4.0.0/000077500000000000000000000000001435240002400175015ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/.dockerignore000066400000000000000000000000131435240002400221470ustar00rootroot00000000000000Dockerfile python-suitesparse-graphblas-7.4.0.0/.gitattributes000066400000000000000000000000571435240002400223760ustar00rootroot00000000000000suitesparse_graphblas/_version.py export-subst python-suitesparse-graphblas-7.4.0.0/.github/000077500000000000000000000000001435240002400210415ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/.github/dependabot.yml000066400000000000000000000001661435240002400236740ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: 'github-actions' directory: '/' schedule: interval: 'weekly' python-suitesparse-graphblas-7.4.0.0/.github/workflows/000077500000000000000000000000001435240002400230765ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/.github/workflows/test.yml000066400000000000000000000044061435240002400246040ustar00rootroot00000000000000name: 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.8", "3.9", "3.10", "3.11"] graphblas-version: ["7.4.0"] steps: - name: Checkout uses: actions/checkout@v3 - name: Conda uses: conda-incubator/setup-miniconda@v2 with: auto-update-conda: true python-version: ${{ matrix.python-version }} environment-file: continuous_integration/environment.yml channels: conda-forge activate-environment: suitesparse-graphblas - name: GraphBLAS (from conda-forge) if: (contains(matrix.source, 'conda-forge')) run: | conda install -c conda-forge graphblas=${{ matrix.graphblas-version }} pytest pytest-randomly - name: GraphBLAS (from source) if: (contains(matrix.source, 'source')) run: | # This isn't working! Why not? # sh suitesparse.sh refs/tags/${{ matrix.graphblas-version }} curl -L https://github.com/DrTimothyAldenDavis/GraphBLAS/archive/refs/tags/v${{ matrix.graphblas-version }}.tar.gz | tar xzf - pushd GraphBLAS-${{ matrix.graphblas-version }}/build echo ${CONDA_PREFIX} cmake -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: | python setup.py build_ext --inplace python setup.py develop - name: Test env: CYTHON_COVERAGE: true run: | coverage run --branch -m pytest coverage run -a --branch suitesparse_graphblas/tests/test_initialize.py - name: Lint run: | black *py suitesparse_graphblas --check --diff flake8 *py suitesparse_graphblas - 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 python-suitesparse-graphblas-7.4.0.0/.github/workflows/wheels.yml000066400000000000000000000020161435240002400251070ustar00rootroot00000000000000name: Python wheel package build and publish on: release: types: [created] jobs: wheels: runs-on: ${{ matrix.os }} defaults: run: shell: bash -l {0} strategy: fail-fast: false matrix: os: ["ubuntu-latest"] steps: - name: Checkout uses: actions/checkout@v3 - name: Set up Python uses: actions/setup-python@v4 with: python-version: '3.8' - name: Upgrade pip run: | python -m pip install --upgrade pip - name: Build manylinux Python wheels uses: RalfG/python-wheels-manylinux-build@v0.4.2-manylinux2014_x86_64 with: python-versions: 'cp38-cp38 cp39-cp39' build-requirements: 'cffi numpy>=1.19,<1.20 cython' pre-build-command: ${{ format('sh suitesparse.sh {0}', github.ref) }} - name: Publish wheels to PyPI env: TWINE_USERNAME: __token__ TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }} run: | pip install twine twine upload dist/*-manylinux*.whl python-suitesparse-graphblas-7.4.0.0/.gitignore000066400000000000000000000034401435240002400214720ustar00rootroot00000000000000# Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] *$py.class # C extensions *.so # Distribution / packaging .Python build/ develop-eggs/ dist/ downloads/ eggs/ .eggs/ lib/ lib64/ parts/ sdist/ var/ wheels/ pip-wheel-metadata/ share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST # PyInstaller # Usually these files are written by a python script from a template # before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec # Installer logs pip-log.txt pip-delete-this-directory.txt # Unit test / coverage reports htmlcov/ .tox/ .nox/ .coverage .coverage.* .cache nosetests.xml coverage.xml *.cover *.py,cover .hypothesis/ .pytest_cache/ # Translations *.mo *.pot # Django stuff: *.log local_settings.py db.sqlite3 db.sqlite3-journal # Flask stuff: instance/ .webassets-cache # Scrapy stuff: .scrapy # Sphinx documentation docs/_build/ # PyBuilder target/ # Jupyter Notebook .ipynb_checkpoints # IPython profile_default/ ipython_config.py # pyenv .python-version # pipenv # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. # However, in case of collaboration, if having platform-specific dependencies or dependencies # having no cross-platform support, pipenv may install dependencies that don't work, or not # install all needed dependencies. #Pipfile.lock # PEP 582; used by e.g. github.com/David-OConnor/pyflow __pypackages__/ # Celery stuff celerybeat-schedule celerybeat.pid # SageMath parsed files *.sage.py # Environments .env .venv env/ venv/ ENV/ env.bak/ venv.bak/ # Spyder project settings .spyderproject .spyproject # Rope project settings .ropeproject # mkdocs documentation /site # mypy .mypy_cache/ .dmypy.json dmypy.json # Pyre type checker .pyre/ # emacs *~ # Vim *.sw? python-suitesparse-graphblas-7.4.0.0/Dockerfile000066400000000000000000000031601435240002400214730ustar00rootroot00000000000000ARG 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 python-suitesparse-graphblas-7.4.0.0/LICENSE000066400000000000000000000261541435240002400205160ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. 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. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. python-suitesparse-graphblas-7.4.0.0/MANIFEST.in000066400000000000000000000003771435240002400212460ustar00rootroot00000000000000include setup.py include README.md include LICENSE include suitesparse_graphblas/*.pxd include suitesparse_graphblas/*.pyx include suitesparse_graphblas/*.c include suitesparse_graphblas/*.h include versioneer.py include suitesparse_graphblas/_version.py python-suitesparse-graphblas-7.4.0.0/README.md000066400000000000000000000016621435240002400207650ustar00rootroot00000000000000# 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 [python-graphblas](https://github.com/python-graphblas/python-graphblas). python-suitesparse-graphblas-7.4.0.0/continuous_integration/000077500000000000000000000000001435240002400243125ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/continuous_integration/environment.yml000066400000000000000000000002621435240002400274010ustar00rootroot00000000000000name: suitesparse-graphblas channels: - conda-forge - defaults dependencies: # - graphblas=6.0.2 - cffi - cython - numpy - pytest - coverage - black - flake8 python-suitesparse-graphblas-7.4.0.0/docker_build.sh000077500000000000000000000022151435240002400224660ustar00rootroot00000000000000if [ $# -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 python-suitesparse-graphblas-7.4.0.0/pyproject.toml000066400000000000000000000001531435240002400224140ustar00rootroot00000000000000[build-system] requires = ["setuptools", "wheel", "numpy>=1.19", "cython"] [tool.black] line-length = 100 python-suitesparse-graphblas-7.4.0.0/setup.cfg000066400000000000000000000017211435240002400213230ustar00rootroot00000000000000[aliases] test=pytest [flake8] max-line-length = 100 inline-quotes = " exclude = versioneer.py, extend-ignore = E203, # E203 whitespace before ':' (to be compatible with black) per-file-ignores = suitesparse_graphblas/io/binary.py:C408 [coverage:run] source = suitesparse_graphblas plugins = Cython.Coverage omit = suitesparse_graphblas/_version.py [coverage:report] # Regexes for lines to exclude from consideration exclude_lines = pragma: no cover raise AssertionError raise NotImplementedError [versioneer] VCS = git style = pep440 versionfile_source = suitesparse_graphblas/_version.py versionfile_build = suitesparse_graphblas/_version.py tag_prefix= parentdir_prefix=suitesparse_graphblas- [tool:pytest] testpaths = suitesparse_graphblas/tests [isort] sections = FUTURE,STDLIB,THIRDPARTY,FIRSTPARTY,LOCALFOLDER profile = black skip_gitignore = true float_to_top = true default_section = THIRDPARTY known_first_party = suitesparse_graphblas python-suitesparse-graphblas-7.4.0.0/setup.py000066400000000000000000000067201435240002400212200ustar00rootroot00000000000000# Twiddle Dee (switch this between Dee and Dum to add meaningless git commits) import os import sys from glob import glob import numpy as np from setuptools import Extension, find_packages, setup import versioneer try: from Cython.Build import cythonize from Cython.Compiler.Options import get_directive_defaults use_cython = True except ImportError: use_cython = False is_win = sys.platform.startswith("win") define_macros = [("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")] 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, ) for name in glob(f"suitesparse_graphblas/**/*{suffix}", recursive=True) ] if use_cython: ext_modules = cythonize(ext_modules, include_path=include_dirs) with open("README.md") as f: long_description = f.read() package_data = {"suitesparse_graphblas": ["*.pyx", "*.pxd", "*.c", "*.h"]} if is_win: package_data["suitesparse_graphblas"].append("*.dll") setup( name="suitesparse-graphblas", version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), description="SuiteSparse:GraphBLAS Python bindings.", long_description=long_description, long_description_content_type="text/markdown", packages=find_packages(), author="Michel Pelletier, James Kitchen, Erik Welch", author_email="michel@graphegon.com,jim22k@gmail.com,erik.n.welch@gmail.com", url="https://github.com/GraphBLAS/python-suitesparse-graphblas", ext_modules=ext_modules, cffi_modules=["suitesparse_graphblas/build.py:ffibuilder"], python_requires=">=3.8", install_requires=["cffi>=1.0.0", "numpy>=1.19"], setup_requires=["cffi>=1.0.0", "pytest-runner"], tests_require=["pytest"], license="Apache License 2.0", package_data=package_data, include_package_data=True, classifiers=[ "Development Status :: 4 - Beta", "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.8", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3 :: Only", "Intended Audience :: Science/Research", "Topic :: Scientific/Engineering", "Topic :: Scientific/Engineering :: Mathematics", ], zip_safe=False, ) python-suitesparse-graphblas-7.4.0.0/suitesparse.sh000066400000000000000000000005221435240002400224030ustar00rootroot00000000000000 if [[ $1 =~ refs/tags/([0-9]*\.[0-9]*\.[0-9]*)\..*$ ]]; then VERSION=${BASH_REMATCH[1]} else exit -1 fi echo VERSION: $VERSION curl -L https://github.com/DrTimothyAldenDavis/GraphBLAS/archive/refs/tags/v${VERSION}.tar.gz | tar xzf - cd GraphBLAS-${VERSION}/build cmake .. -DCMAKE_BUILD_TYPE=Release make -j$(nproc) make install python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/000077500000000000000000000000001435240002400240735ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/__init__.py000066400000000000000000000211531435240002400262060ustar00rootroot00000000000000from . import _version from . import exceptions as ex from . import utils from ._graphblas import ffi, lib import struct import platform _is_osx_arm64 = platform.machine() == "arm64" _is_ppc64le = platform.machine() == "ppc64le" _c_float = ffi.typeof("float") _c_double = ffi.typeof("double") # 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, } 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_SelectOp_opaque *": lib.GxB_SelectOp_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() __version__ = _version.get_versions()["version"] python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/_version.py000066400000000000000000000551741435240002400263050ustar00rootroot00000000000000# This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. # This file is released into the public domain. Generated by # versioneer-0.21 (https://github.com/python-versioneer/python-versioneer) """Git implementation of _version.py.""" import errno import os import re import subprocess import sys from typing import Callable, Dict def get_keywords(): """Get the keywords needed to look up the version information.""" # these strings will be replaced by git during git-archive. # setup.py/versioneer.py will grep for the variable names, so they must # each be defined on a line of their own. _version.py will just call # get_keywords(). git_refnames = " (HEAD -> main, tag: 7.4.0.0)" git_full = "d36c2cf53d75587b20ddf11e67f48637cd530aaa" git_date = "2022-12-26 14:12:04 -0600" keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} return keywords class VersioneerConfig: """Container for Versioneer configuration parameters.""" def get_config(): """Create, populate and return the VersioneerConfig() object.""" # these strings are filled in when 'setup.py versioneer' creates # _version.py cfg = VersioneerConfig() cfg.VCS = "git" cfg.style = "pep440" cfg.tag_prefix = "" cfg.parentdir_prefix = "suitesparse_graphblas-" cfg.versionfile_source = "suitesparse_graphblas/_version.py" cfg.verbose = False return cfg class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" LONG_VERSION_PY: Dict[str, str] = {} HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator """Create decorator to mark a method as the handler of a VCS.""" def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f return decorate def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) process = None for command in commands: try: dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git process = subprocess.Popen( [command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None), ) break except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % dispcmd) print(e) return None, None else: if verbose: print(f"unable to find command, tried {commands}") return None, None stdout = process.communicate()[0].strip().decode() if process.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) print("stdout was %s" % stdout) return None, process.returncode return stdout, process.returncode def versions_from_parentdir(parentdir_prefix, root, verbose): """Try to determine the version from the parent directory name. Source tarballs conventionally unpack into a directory that includes both the project name and a version string. We will also support searching up two directory levels for an appropriately named parent directory """ rootdirs = [] for _ in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): return { "version": dirname[len(parentdir_prefix) :], "full-revisionid": None, "dirty": False, "error": None, "date": None, } rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: print( "Tried directories %s but none started with prefix %s" % (str(rootdirs), parentdir_prefix) ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @register_vcs_handler("git", "get_keywords") def git_get_keywords(versionfile_abs): """Extract version information from the given file.""" # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: with open(versionfile_abs) as fobj: for line in fobj: if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) if line.strip().startswith("git_date ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) except OSError: pass return keywords @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" if "refnames" not in keywords: raise NotThisMethod("Short version file found") date = keywords.get("date") if date is not None: # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 # -like" string, which we must then edit to make compliant), because # it's been around since git-1.5.3, and it's too difficult to # discover which version we're using, or to work around using an # older one. date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = {r for r in refs if re.search(r"\d", r)} if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix) :] # Filter out refs that exactly match prefix or that don't start # with a number once the prefix is stripped (mostly a concern # when prefix is '') if not re.match(r"\d", r): continue if verbose: print("picking %s" % r) return { "version": r, "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None, "date": date, } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return { "version": "0+unknown", "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags", "date": None, } @register_vcs_handler("git", "pieces_from_vcs") def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* expanded, and _version.py hasn't already been rewritten with a short version string, meaning we're inside a checked out source tree. """ GITS = ["git"] TAG_PREFIX_REGEX = "*" if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] TAG_PREFIX_REGEX = r"\*" _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) if rc != 0: if verbose: print("Directory %s not under git control" % root) raise NotThisMethod("'git rev-parse --git-dir' returned error") # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) describe_out, rc = runner( GITS, [ "describe", "--tags", "--dirty", "--always", "--long", "--match", f"{tag_prefix}{TAG_PREFIX_REGEX}", ], cwd=root, ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() pieces = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) # --abbrev-ref was added in git-1.6.3 if rc != 0 or branch_name is None: raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") branch_name = branch_name.strip() if branch_name == "HEAD": # If we aren't exactly on a branch, pick a branch which represents # the current commit. If all else fails, we are on a branchless # commit. branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) # --contains was added in git-1.5.4 if rc != 0 or branches is None: raise NotThisMethod("'git branch --contains' returned error") branches = branches.split("\n") # Remove the first line if we're running detached if "(" in branches[0]: branches.pop(0) # Strip off the leading "* " from the list of branches. branches = [branch[2:] for branch in branches] if "master" in branches: branch_name = "master" elif not branches: branch_name = None else: # Pick the first branch that is returned. Good or bad. branch_name = branches[0] pieces["branch"] = branch_name # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out # look for -dirty suffix dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: # unparsable. Maybe git-describe is misbehaving? pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out return pieces # tag full_tag = mo.group(1) if not full_tag.startswith(tag_prefix): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) pieces["error"] = f"tag '{full_tag}' doesn't start with prefix '{tag_prefix}'" return pieces pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) # commit: short hex revision ID pieces["short"] = mo.group(3) else: # HEX: no tags pieces["closest-tag"] = None count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces def plus_or_dot(pieces): """Return a + if we don't already have one, else return a .""" if "+" in pieces.get("closest-tag", ""): return "." return "+" def render_pep440(pieces): """Build up version string, with post-release "local version identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty Exceptions: 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += plus_or_dot(pieces) rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_branch(pieces): """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . The ".dev0" means not master branch. Note that .dev0 sorts backwards (a feature branch will appear "older" than the master branch). Exceptions: 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: if pieces["branch"] != "master": rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0" if pieces["branch"] != "master": rendered += ".dev0" rendered += "+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def pep440_split_post(ver): """Split pep440 version string at the post-release segment. Returns the release segments before the post-release and the post-release version number (or -1 if no post-release segment is present). """ vc = str.split(ver, ".post") return vc[0], int(vc[1] or 0) if len(vc) == 2 else None def render_pep440_pre(pieces): """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: if pieces["distance"]: # update the post release segment tag_version, post_version = pep440_split_post(pieces["closest-tag"]) rendered = tag_version if post_version is not None: rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) else: rendered += ".post0.dev%d" % (pieces["distance"]) else: # no commits, use the tag as the version rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%d" % pieces["distance"] return rendered def render_pep440_post(pieces): """TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that .dev0 sorts backwards (a dirty tree will appear "older" than the corresponding clean one), but you shouldn't be releasing software with -dirty anyways. Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%s" % pieces["short"] else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += "+g%s" % pieces["short"] return rendered def render_pep440_post_branch(pieces): """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . The ".dev0" means not master branch. Exceptions: 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["branch"] != "master": rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%s" % pieces["short"] if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["branch"] != "master": rendered += ".dev0" rendered += "+g%s" % pieces["short"] if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" return rendered def render_git_describe(pieces): """TAG[-DISTANCE-gHEX][-dirty]. Like 'git describe --tags --dirty --always'. Exceptions: 1: no tags. HEX[-dirty] (note: no 'g' prefix) """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render_git_describe_long(pieces): """TAG-DISTANCE-gHEX[-dirty]. Like 'git describe --tags --dirty --always -long'. The distance/hash is unconditional. Exceptions: 1: no tags. HEX[-dirty] (note: no 'g' prefix) """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: return { "version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"], "date": None, } if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) elif style == "pep440-branch": rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) elif style == "pep440-post-branch": rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": rendered = render_git_describe(pieces) elif style == "git-describe-long": rendered = render_git_describe_long(pieces) else: raise ValueError("unknown style '%s'" % style) return { "version": rendered, "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None, "date": pieces.get("date"), } def get_versions(): """Get version information or return default if unable to do so.""" # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which # case we can only use expanded keywords. cfg = get_config() verbose = cfg.verbose try: return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) except NotThisMethod: pass try: root = os.path.realpath(__file__) # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. for _ in cfg.versionfile_source.split("/"): root = os.path.dirname(root) except NameError: return { "version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to find root of source tree", "date": None, } try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) return render(pieces, cfg.style) except NotThisMethod: pass try: if cfg.parentdir_prefix: return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) except NotThisMethod: pass return { "version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to compute version", "date": None, } python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/build.py000066400000000000000000000021121435240002400255400ustar00rootroot00000000000000import os import sys import platform from cffi import FFI is_win = sys.platform.startswith("win") is_arm64 = platform.machine() == "arm64" is_ppc64le = platform.machine() == "ppc64le" # Use same header as arm64, which *may* work thisdir = os.path.dirname(__file__) ffibuilder = FFI() with open(os.path.join(thisdir, "source.c")) as f: source = f.read() include_dirs = [os.path.join(sys.prefix, "include")] library_dirs = [os.path.join(sys.prefix, "lib")] if is_win: include_dirs.append(os.path.join(sys.prefix, "Library", "include")) library_dirs.append(os.path.join(sys.prefix, "Library", "lib")) ffibuilder.set_source( "suitesparse_graphblas._graphblas", source, libraries=["graphblas"], include_dirs=include_dirs, library_dirs=library_dirs, ) header = "suitesparse_graphblas.h" if is_win: header = "suitesparse_graphblas_no_complex.h" if is_arm64 or is_ppc64le: header = "suitesparse_graphblas_arm64.h" gb_cdef = open(os.path.join(thisdir, header)) ffibuilder.cdef(gb_cdef.read()) if __name__ == "__main__": ffibuilder.compile(verbose=True) python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/create_headers.py000066400000000000000000000671501435240002400274140ustar00rootroot00000000000000""" Script to generate suitesparse_graphblas.h, suitesparse_graphblas_no_complex.h, and source.c files. - Copy the SuiteSparse header file GraphBLAS.h to the local directory. - Run the C preprocessor (cleans it up, but also loses #define values). - Parse the processed header file using pycparser. - Create the final files with and without complex types. - Check #define values for sanity. The generated files are then used by cffi to bind to SuiteSparse:GraphBLAS. When running against new versions of SuiteSparse:GraphBLAS, the most likely things that may need to change are: - Update DEFINES, the integer #define constants defined by SuiteSparse. - Update CHAR_DEFINES, the char* #defines. - Update IGNORE_DEFINES, #defines that the script may mistakingly identity, but that we can safely ignore. - Update DEPRECATED: deprecated names (including enum fields) to exclude. 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'""" return string.replace("8", "08") def has_complex(string): return "FC32" in string or "FC64" in string def groupby(index, seq): rv = {} for item in seq: key = item[index] if key in rv: rv[key].append(item) else: rv[key] = [item] return rv AUTO = "/* This file is automatically generated */" DEPRECATED = { # enums "GxB_IS_HYPER", "GrB_SCMP", # functions "GxB_kron", "GxB_Matrix_resize", "GxB_Vector_resize", # UnaryOp "GxB_ABS_BOOL", "GxB_ABS_INT8", "GxB_ABS_INT16", "GxB_ABS_INT32", "GxB_ABS_INT64", "GxB_ABS_UINT8", "GxB_ABS_UINT16", "GxB_ABS_UINT32", "GxB_ABS_UINT64", "GxB_ABS_FP32", "GxB_ABS_FP64", # Monoids "GxB_MIN_INT8_MONOID", "GxB_MIN_INT16_MONOID", "GxB_MIN_INT32_MONOID", "GxB_MIN_INT64_MONOID", "GxB_MIN_UINT8_MONOID", "GxB_MIN_UINT16_MONOID", "GxB_MIN_UINT32_MONOID", "GxB_MIN_UINT64_MONOID", "GxB_MIN_FP32_MONOID", "GxB_MIN_FP64_MONOID", "GxB_MAX_INT8_MONOID", "GxB_MAX_INT16_MONOID", "GxB_MAX_INT32_MONOID", "GxB_MAX_INT64_MONOID", "GxB_MAX_UINT8_MONOID", "GxB_MAX_UINT16_MONOID", "GxB_MAX_UINT32_MONOID", "GxB_MAX_UINT64_MONOID", "GxB_MAX_FP32_MONOID", "GxB_MAX_FP64_MONOID", "GxB_PLUS_INT8_MONOID", "GxB_PLUS_INT16_MONOID", "GxB_PLUS_INT32_MONOID", "GxB_PLUS_INT64_MONOID", "GxB_PLUS_UINT8_MONOID", "GxB_PLUS_UINT16_MONOID", "GxB_PLUS_UINT32_MONOID", "GxB_PLUS_UINT64_MONOID", "GxB_PLUS_FP32_MONOID", "GxB_PLUS_FP64_MONOID", "GxB_TIMES_INT8_MONOID", "GxB_TIMES_INT16_MONOID", "GxB_TIMES_INT32_MONOID", "GxB_TIMES_INT64_MONOID", "GxB_TIMES_UINT8_MONOID", "GxB_TIMES_UINT16_MONOID", "GxB_TIMES_UINT32_MONOID", "GxB_TIMES_UINT64_MONOID", "GxB_TIMES_FP32_MONOID", "GxB_TIMES_FP64_MONOID", "GxB_LOR_BOOL_MONOID", "GxB_LAND_BOOL_MONOID", "GxB_LXOR_BOOL_MONOID", "GxB_LXNOR_BOOL_MONOID", # "GxB_EQ_BOOL_MONOID", # XXX: I prefer this name to GrB_LXNOR_MONOID_BOOL # Semirings "GxB_PLUS_TIMES_INT8", "GxB_PLUS_TIMES_INT16", "GxB_PLUS_TIMES_INT32", "GxB_PLUS_TIMES_INT64", "GxB_PLUS_TIMES_UINT8", "GxB_PLUS_TIMES_UINT16", "GxB_PLUS_TIMES_UINT32", "GxB_PLUS_TIMES_UINT64", "GxB_PLUS_TIMES_FP32", "GxB_PLUS_TIMES_FP64", "GxB_PLUS_MIN_INT8", "GxB_PLUS_MIN_INT16", "GxB_PLUS_MIN_INT32", "GxB_PLUS_MIN_INT64", "GxB_PLUS_MIN_UINT8", "GxB_PLUS_MIN_UINT16", "GxB_PLUS_MIN_UINT32", "GxB_PLUS_MIN_UINT64", "GxB_PLUS_MIN_FP32", "GxB_PLUS_MIN_FP64", "GxB_MIN_PLUS_INT8", "GxB_MIN_PLUS_INT16", "GxB_MIN_PLUS_INT32", "GxB_MIN_PLUS_INT64", "GxB_MIN_PLUS_UINT8", "GxB_MIN_PLUS_UINT16", "GxB_MIN_PLUS_UINT32", "GxB_MIN_PLUS_UINT64", "GxB_MIN_PLUS_FP32", "GxB_MIN_PLUS_FP64", "GxB_MIN_TIMES_INT8", "GxB_MIN_TIMES_INT16", "GxB_MIN_TIMES_INT32", "GxB_MIN_TIMES_INT64", "GxB_MIN_TIMES_UINT8", "GxB_MIN_TIMES_UINT16", "GxB_MIN_TIMES_UINT32", "GxB_MIN_TIMES_UINT64", "GxB_MIN_TIMES_FP32", "GxB_MIN_TIMES_FP64", "GxB_MIN_FIRST_INT8", "GxB_MIN_FIRST_INT16", "GxB_MIN_FIRST_INT32", "GxB_MIN_FIRST_INT64", "GxB_MIN_FIRST_UINT8", "GxB_MIN_FIRST_UINT16", "GxB_MIN_FIRST_UINT32", "GxB_MIN_FIRST_UINT64", "GxB_MIN_FIRST_FP32", "GxB_MIN_FIRST_FP64", "GxB_MIN_SECOND_INT8", "GxB_MIN_SECOND_INT16", "GxB_MIN_SECOND_INT32", "GxB_MIN_SECOND_INT64", "GxB_MIN_SECOND_UINT8", "GxB_MIN_SECOND_UINT16", "GxB_MIN_SECOND_UINT32", "GxB_MIN_SECOND_UINT64", "GxB_MIN_SECOND_FP32", "GxB_MIN_SECOND_FP64", "GxB_MIN_MAX_INT8", "GxB_MIN_MAX_INT16", "GxB_MIN_MAX_INT32", "GxB_MIN_MAX_INT64", "GxB_MIN_MAX_UINT8", "GxB_MIN_MAX_UINT16", "GxB_MIN_MAX_UINT32", "GxB_MIN_MAX_UINT64", "GxB_MIN_MAX_FP32", "GxB_MIN_MAX_FP64", "GxB_MAX_PLUS_INT8", "GxB_MAX_PLUS_INT16", "GxB_MAX_PLUS_INT32", "GxB_MAX_PLUS_INT64", "GxB_MAX_PLUS_UINT8", "GxB_MAX_PLUS_UINT16", "GxB_MAX_PLUS_UINT32", "GxB_MAX_PLUS_UINT64", "GxB_MAX_PLUS_FP32", "GxB_MAX_PLUS_FP64", "GxB_MAX_TIMES_INT8", "GxB_MAX_TIMES_INT16", "GxB_MAX_TIMES_INT32", "GxB_MAX_TIMES_INT64", "GxB_MAX_TIMES_UINT8", "GxB_MAX_TIMES_UINT16", "GxB_MAX_TIMES_UINT32", "GxB_MAX_TIMES_UINT64", "GxB_MAX_TIMES_FP32", "GxB_MAX_TIMES_FP64", "GxB_MAX_FIRST_INT8", "GxB_MAX_FIRST_INT16", "GxB_MAX_FIRST_INT32", "GxB_MAX_FIRST_INT64", "GxB_MAX_FIRST_UINT8", "GxB_MAX_FIRST_UINT16", "GxB_MAX_FIRST_UINT32", "GxB_MAX_FIRST_UINT64", "GxB_MAX_FIRST_FP32", "GxB_MAX_FIRST_FP64", "GxB_MAX_SECOND_INT8", "GxB_MAX_SECOND_INT16", "GxB_MAX_SECOND_INT32", "GxB_MAX_SECOND_INT64", "GxB_MAX_SECOND_UINT8", "GxB_MAX_SECOND_UINT16", "GxB_MAX_SECOND_UINT32", "GxB_MAX_SECOND_UINT64", "GxB_MAX_SECOND_FP32", "GxB_MAX_SECOND_FP64", "GxB_MAX_MIN_INT8", "GxB_MAX_MIN_INT16", "GxB_MAX_MIN_INT32", "GxB_MAX_MIN_INT64", "GxB_MAX_MIN_UINT8", "GxB_MAX_MIN_UINT16", "GxB_MAX_MIN_UINT32", "GxB_MAX_MIN_UINT64", "GxB_MAX_MIN_FP32", "GxB_MAX_MIN_FP64", "GxB_LOR_LAND_BOOL", "GxB_LAND_LOR_BOOL", "GxB_LXOR_LAND_BOOL", # "GxB_EQ_LOR_BOOL", # XXX: I prefer this name to GrB_LXNOR_LOR_SEMIRING_BOOL # Old deprecated (probably already removed) "GrB_eWiseMult_Vector_Semiring", "GrB_eWiseMult_Vector_Monoid", "GrB_eWiseMult_Vector_BinaryOp", "GrB_eWiseMult_Matrix_Semiring", "GrB_eWiseMult_Matrix_Monoid", "GrB_eWiseMult_Matrix_BinaryOp", "GrB_eWiseAdd_Vector_Semiring", "GrB_eWiseAdd_Vector_Monoid", "GrB_eWiseAdd_Vector_BinaryOp", "GrB_eWiseAdd_Matrix_Semiring", "GrB_eWiseAdd_Matrix_Monoid", "GrB_eWiseAdd_Matrix_BinaryOp", } DEFINES = { "GrB_INDEX_MAX", "GxB_STDC_VERSION", "GxB_IMPLEMENTATION_MAJOR", "GxB_IMPLEMENTATION_MINOR", "GxB_IMPLEMENTATION_SUB", "GxB_SPEC_MAJOR", "GxB_SPEC_MINOR", "GxB_SPEC_SUB", "GxB_IMPLEMENTATION", "GxB_SPEC_VERSION", "GxB_INDEX_MAX", "GRB_VERSION", "GRB_SUBVERSION", "GxB_NTHREADS", "GxB_CHUNK", "GxB_GPU_CONTROL", "GxB_GPU_CHUNK", "GxB_HYPERSPARSE", "GxB_SPARSE", "GxB_BITMAP", "GxB_FULL", "GxB_NBITMAP_SWITCH", "GxB_ANY_SPARSITY", "GxB_AUTO_SPARSITY", "GxB_RANGE", "GxB_STRIDE", "GxB_BACKWARDS", "GxB_BEGIN", "GxB_END", "GxB_INC", "GxB_FAST_IMPORT", "GxB_MAX_NAME_LEN", "GxB_COMPRESSION_DEFAULT", "GxB_COMPRESSION_INTEL", "GxB_COMPRESSION_LZ4", "GxB_COMPRESSION_LZ4HC", "GxB_COMPRESSION_ZSTD", "GxB_COMPRESSION_NONE", } CHAR_DEFINES = { "GxB_IMPLEMENTATION_NAME", "GxB_IMPLEMENTATION_DATE", "GxB_SPEC_DATE", "GxB_IMPLEMENTATION_ABOUT", "GxB_IMPLEMENTATION_LICENSE", "GxB_SPEC_ABOUT", } IGNORE_DEFINES = { "GrB", "GxB", "CMPLX", "CMPLXF", "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", # 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): super().__init__(*args, **kwargs) self.results = [] def visit_Typedef(self, node): rv = super().visit_Typedef(node) if isinstance(node.type.type, c_ast.Enum): 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}") return ast def get_groups(ast): generator = c_generator.CGenerator() lines = generator.visit(ast).splitlines() seen = set() groups = {} vals = {x for x in lines if "extern GrB_Info GxB" in x} - seen vals |= {x for x in lines if "extern " in x and "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 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 "extern " in x and "GxB_Iterator" in x and "GB" 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, ", ".join(sorted(missing_methods)) vals = {x for x in lines if "extern GrB" in x} - seen seen.update(vals) groups["GrB objects"] = sorted(vals, key=sort_key) vals = {x for x in lines if "extern GxB" in x} - seen seen.update(vals) groups["GxB objects"] = sorted(vals, key=sort_key) vals = {x for x in lines if "extern const" in x and "GxB" in x} - seen seen.update(vals) groups["GxB const"] = sorted(vals, key=sort_key) vals = {x for x in lines if "extern const" in x and "GrB" in x} - seen seen.update(vals) 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, ", ".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) groups["GxB typedef"] = sorted(vals, key=sort_key) vals = {x for x in lines if "typedef" in x and "GrB" in x and "(" not in x} - seen 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, ", ".join(sorted(missing_typedefs)) assert all(x.endswith(";") for x in seen) # sanity check g = VisitEnumTypedef() _ = g.visit(ast) enums = g.results 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])) 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])) 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, ", ".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 def get_group_info(groups, ast, *, skip_complex=False): rv = {} def handle_constants(group): for line in group: extern, const, ctype, name = line.split(" ") assert name.endswith(";") name = name[:-1].replace("(void)", "()") assert extern == "extern" assert const == "const" if name in DEPRECATED: continue if skip_complex and has_complex(line): continue info = { "text": line, } yield info rv["GrB const"] = list(handle_constants(groups["GrB const"])) rv["GxB const"] = list(handle_constants(groups["GxB const"])) def handle_objects(group): for line in group: extern, ctype, name = line.split(" ") assert name.endswith(";") name = name[:-1] assert extern == "extern" if name in DEPRECATED: continue if skip_complex and has_complex(line): continue info = { "text": line, } yield info rv["GrB objects"] = list(handle_objects(groups["GrB objects"])) rv["GxB objects"] = list(handle_objects(groups["GxB objects"])) def handle_enums(group): for text in group: text = text.replace("enum \n", "enum\n") typedef, bracket, *fields, name = text.splitlines() assert typedef.strip() == "typedef enum" assert bracket == "{" assert name.startswith("}") assert name.endswith(";") name = name[1:-1].strip() if name in DEPRECATED: continue if skip_complex and has_complex(name): continue # Break this open so we can remove unwanted deprecated fields. # Instead of traversing the AST, munging string is good enough. typedef, bracket, *fields, cname = text.splitlines() typedef = typedef.strip() assert typedef.strip() == "typedef enum" assert bracket == "{" assert cname.startswith("}") assert cname.endswith(";") new_fields = [] for field in fields: if field.endswith(","): field = field[:-1] field = field.strip() cfieldname, eq, val = field.split(" ") assert eq == "=" if cfieldname in DEPRECATED: continue if skip_complex and has_complex(cfieldname): continue new_fields.append(field) if not new_fields: continue lines = [typedef, bracket] for field in new_fields: lines.append(f" {field},") lines[-1] = lines[-1][:-1] # remove last comma lines.append(cname) info = { "orig_text": text, "text": "\n".join(lines), } yield info rv["GrB typedef enums"] = list(handle_enums(groups["GrB typedef enums"])) rv["GxB typedef enums"] = list(handle_enums(groups["GxB typedef enums"])) def handle_typedefs(group): for line in group: typedef, *ctypes, name = line.split(" ") assert typedef == "typedef" assert name.endswith(";") name = name[:-1] if name in DEPRECATED: continue if skip_complex and has_complex(line): continue info = { "text": line, } yield info rv["GrB typedef"] = list(handle_typedefs(groups["GrB typedef"])) rv["GxB typedef"] = list(handle_typedefs(groups["GxB typedef"])) def handle_typedef_funcs(group): for line in group: assert line.endswith(";") and line.startswith("typedef") if skip_complex and has_complex(line): continue info = { "text": line, } yield info rv["GxB typedef funcs"] = list(handle_typedef_funcs(groups["GxB typedef funcs"])) 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"]: self.functions.append(node) def handle_function_node(node): 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 text = generator.visit(node) text += ";" if skip_complex and has_complex(text): return if "GrB_Matrix" in text: group = "matrix" elif "GrB_Vector" in text: group = "vector" 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", "BinaryOp": "binary", "Desc": "descriptor", "Descriptor": "descriptor", "Monoid": "monoid", "Semiring": "semiring", "Type": "type", "UnaryOp": "unary", "IndexUnaryOp": "indexunary", "Iterator": "iterator", # "everything else" is "core" "getVersion": "core", "Global": "core", "cuda": "core", "finalize": "core", "init": "core", "wait": "core", "deserialize": "core", }[group] return { "name": node.name, "group": group, "node": node, "text": text, } generator = c_generator.CGenerator() visitor = FuncDeclVisitor() visitor.visit(ast) 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"]), ( len(grb_nodes), len(groups["GrB methods"]), ) 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) gb_funcs = (handle_function_node(node) for node in gb_nodes) grb_funcs = [x for x in grb_funcs if x is not None] gxb_funcs = [x for x in gxb_funcs if x is not None] gb_funcs = [x for x in gb_funcs if x is not None] rv["GrB methods"] = sorted(grb_funcs, key=lambda x: sort_key(x["text"])) rv["GxB methods"] = sorted(gxb_funcs, key=lambda x: sort_key(x["text"])) rv["GB methods"] = sorted(gb_funcs, key=lambda x: sort_key(x["text"])) for key in groups.keys() - rv.keys(): rv[key] = groups[key] return rv def parse_header(filename, *, skip_complex=False): ast = get_ast(filename) groups = get_groups(ast) return get_group_info(groups, ast, skip_complex=skip_complex) def create_header_text(groups, *, char_defines=None, defines=None): if char_defines is None: char_defines = CHAR_DEFINES if defines is None: defines = DEFINES text = [AUTO] text.append("/* GrB typedefs */") for group in groups["GrB typedef"]: text.append(group["text"]) text.append("") text.append("/* GxB typedefs */") for group in groups["GxB typedef"]: text.append(group["text"]) text.append("") text.append("/* GxB typedefs (functions) */") for group in groups["GxB typedef funcs"]: text.append(group["text"]) text.append("") text.append("/* GrB enums */") for group in groups["GrB typedef enums"]: text.append(group["text"]) text.append("") text.append("/* GxB enums */") for group in groups["GxB typedef enums"]: text.append(group["text"]) text.append("") text.append("/* GrB consts */") for group in groups["GrB const"]: text.append(group["text"]) text.append("") text.append("/* GxB consts */") for group in groups["GxB const"]: text.append(group["text"]) text.append("") text.append("/* GrB objects */") for group in groups["GrB objects"]: if "GxB" not in group["text"]: text.append(group["text"]) text.append("") text.append("/* GrB objects (extended) */") for group in groups["GrB objects"]: if "GxB" in group["text"]: text.append(group["text"]) text.append("") text.append("/* GxB objects */") for group in groups["GxB objects"]: text.append(group["text"]) def handle_funcs(group): groups = groupby("group", group) for name in sorted(groups, key=sort_key): yield "" yield f"/* {name} */" for info in groups[name]: yield info["text"] text.append("") text.append("/****************") text.append("* GrB functions *") text.append("****************/") text.extend(handle_funcs(groups["GrB methods"])) text.append("") text.append("/***************") text.append("* GB functions *") text.append("***************/") text.extend(handle_funcs(groups["GB methods"])) text.append("") text.append("/****************") text.append("* GxB functions *") text.append("****************/") text.extend(handle_funcs(groups["GxB methods"])) text.append("") text.append("/* int DEFINES */") for item in sorted(defines, key=sort_key): text.append(f"#define {item} ...") text.append("") text.append("/* char* DEFINES */") for item in sorted(char_defines, key=sort_key): text.append(f"extern char *{item}_STR;") return text def create_source_text(groups, *, char_defines=None): if char_defines is None: char_defines = CHAR_DEFINES text = [ AUTO, '#include "GraphBLAS.h"', ] for item in sorted(char_defines, key=sort_key): text.append(f"char *{item}_STR = {item};") return text def main(): parser = argparse.ArgumentParser() 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"), ) parser.add_argument( "--show-skipped", action="store_true", help="If specified, then print the lines that were skipped when parsing the header file.", ) args = parser.parse_args() thisdir = os.path.dirname(__file__) # copy the original to this file graphblas_h = os.path.join(thisdir, "GraphBLAS-orig.h") # after the preprocessor processed_h = os.path.join(thisdir, "GraphBLAS-processed.h") # 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") # Copy original file print(f"Step 1: copy {args.graphblas} to {graphblas_h}") if not os.path.exists(args.graphblas): raise FileNotFoundError(f"File not found: {args.graphblas}") shutil.copyfile(args.graphblas, graphblas_h) # 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") command = ( f"gcc -nostdinc -E -I{include} {graphblas_h} " f"| sed 's/ complex / _Complex /g' > {processed_h}" ) res = subprocess.run(command, shell=True) if res.returncode != 0: raise RuntimeError("Subprocess command failed", res) # Create final header file print(f"Step 3: parse header file to create {final_h}") 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) + "\n") # 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 5: 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) + "\n") # Create source print(f"Step 6: create {source_c}") text = create_source_text(groups) with open(source_c, "w") as f: f.write("\n".join(text) + "\n") # Check defines print("Step 7: 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 = 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. print( f"WARNING: the following #define values weren't found in {graphblas_h}: " + ", ".join(sorted(extra_defines)) ) 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)) ) print("Success!", "\N{ROCKET}") if args.show_skipped: print() 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) if __name__ == "__main__": main() python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/exceptions.py000066400000000000000000000015001435240002400266220ustar00rootroot00000000000000class 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 python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/io/000077500000000000000000000000001435240002400245025ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/io/__init__.py000066400000000000000000000000001435240002400266010ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/io/binary.py000066400000000000000000000400541435240002400263430ustar00rootroot00000000000000from 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( 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 python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/io/serialize.py000066400000000000000000000116121435240002400270440ustar00rootroot00000000000000import 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 isort:skip python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/matrix.py000066400000000000000000000121601435240002400257510ustar00rootroot00000000000000from suitesparse_graphblas import check_status, ffi, lib from .io.serialize import deserialize_matrix as deserialize # noqa from .io.serialize import serialize_matrix as serialize # noqa 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] python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/scalar.py000066400000000000000000000026601435240002400257160ustar00rootroot00000000000000from 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] python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/source.c000066400000000000000000000006221435240002400255370ustar00rootroot00000000000000/* This file is automatically generated */ #include "GraphBLAS.h" char *GxB_IMPLEMENTATION_ABOUT_STR = GxB_IMPLEMENTATION_ABOUT; 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; python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/suitesparse_graphblas.h000066400000000000000000006172111435240002400306460ustar00rootroot00000000000000/* This file is automatically generated */ /* GrB typedefs */ typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; typedef struct GB_Descriptor_opaque *GrB_Descriptor; 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_Iterator_opaque *GxB_Iterator; 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_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 *); /* 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, GxB_COMPRESSION = 36, GxB_IMPORT = 37 } 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, GxB_SECURE_IMPORT = 502 } 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 = 2, 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_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 } GrB_Info; typedef enum { GrB_NONBLOCKING = 0, GrB_BLOCKING = 1, GxB_NONBLOCKING_GPU = 2, GxB_BLOCKING_GPU = 3 } GrB_Mode; typedef enum { GrB_COMPLETE = 0, GrB_MATERIALIZE = 1 } GrB_WaitMode; /* 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_COMPILER_VERSION = 23, GxB_COMPILER_NAME = 24, GxB_LIBRARY_OPENMP = 25, GxB_GLOBAL_NTHREADS = 5, GxB_GLOBAL_CHUNK = 7, GxB_BURBLE = 99, GxB_PRINTF = 101, GxB_FLUSH = 102, GxB_MEMORY_POOL = 103, GxB_PRINT_1BASED = 104, 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_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_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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* indexunary */ extern GrB_Info GrB_IndexUnaryOp_error(const char **error, const GrB_IndexUnaryOp op); extern GrB_Info GrB_IndexUnaryOp_free(GrB_IndexUnaryOp *op); extern GrB_Info GrB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); extern GrB_Info GrB_IndexUnaryOp_wait(GrB_IndexUnaryOp op, GrB_WaitMode waitmode); /* 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_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); 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_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); 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GrB_Scalar 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_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size); extern GrB_Info GrB_Matrix_diag(GrB_Matrix *C, const GrB_Vector v, int64_t k); 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_exportHint(GrB_Format *format, GrB_Matrix A); extern GrB_Info GrB_Matrix_exportSize(GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, 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_Scalar(GrB_Scalar 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_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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); 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_BinaryOp_Scalar(GrB_Scalar S, 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_Monoid_Scalar(GrB_Scalar c, 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern GrB_Info GrB_Matrix_serialize(void *blob, GrB_Index *blob_size_handle, GrB_Matrix A); extern GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size_handle, GrB_Matrix A); 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_Scalar(GrB_Matrix C, GrB_Scalar 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, GrB_WaitMode waitmode); 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, GrB_WaitMode waitmode); /* scalar */ extern GrB_Info GrB_Scalar_clear(GrB_Scalar s); extern GrB_Info GrB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); extern GrB_Info GrB_Scalar_error(const char **error, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_free(GrB_Scalar *s); extern GrB_Info GrB_Scalar_new(GrB_Scalar *s, GrB_Type type); extern GrB_Info GrB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); extern GrB_Info GrB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); extern GrB_Info GrB_Scalar_setElement_FP32(GrB_Scalar s, float x); extern GrB_Info GrB_Scalar_setElement_FP64(GrB_Scalar s, double x); extern GrB_Info GrB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); extern GrB_Info GrB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); extern GrB_Info GrB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); extern GrB_Info GrB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); extern GrB_Info GrB_Scalar_setElement_UDT(GrB_Scalar s, void *x); extern GrB_Info GrB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); extern GrB_Info GrB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); extern GrB_Info GrB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); extern GrB_Info GrB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); extern GrB_Info GrB_Scalar_wait(GrB_Scalar s, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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_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); 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_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); 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GrB_Scalar 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_Scalar(GrB_Scalar 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_BinaryOp_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_BinaryOp op, 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_Monoid_Scalar(GrB_Scalar 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Vector w, GrB_Scalar 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, GrB_WaitMode waitmode); /*************** * 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 *binop_name); /* iterator */ extern GrB_Info GB_Iterator_rc_bitmap_next(GxB_Iterator iterator); extern GrB_Info GB_Iterator_rc_seek(GxB_Iterator iterator, GrB_Index j, bool jth_vector); extern GrB_Info GB_Vector_Iterator_bitmap_seek(GxB_Iterator iterator, GrB_Index unused); /* matrix */ extern GrB_Info GB_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GxB_Format_Value format, GrB_Descriptor desc); /* 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 *type_name); /* unary */ extern GrB_Info GB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_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_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); extern GrB_Info GxB_BinaryOp_xtype(GrB_Type *xtype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_xtype_name(char *type_name, const GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ytype(GrB_Type *ytype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ytype_name(char *type_name, const GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ztype(GrB_Type *ztype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ztype_name(char *type_name, const GrB_BinaryOp binaryop); /* core */ extern GrB_Info GxB_Global_Option_get(GxB_Option_Field field, ...); extern GrB_Info GxB_Global_Option_get_CHAR(GxB_Option_Field field, char **value); extern GrB_Info GxB_Global_Option_get_FP64(GxB_Option_Field field, double *value); extern GrB_Info GxB_Global_Option_get_FUNCTION(GxB_Option_Field field, void **value); extern GrB_Info GxB_Global_Option_get_INT32(GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Global_Option_get_INT64(GxB_Option_Field field, int64_t *value); extern GrB_Info GxB_Global_Option_set(GxB_Option_Field field, ...); extern GrB_Info GxB_Global_Option_set_FP64(GxB_Option_Field field, double value); extern GrB_Info GxB_Global_Option_set_FP64_ARRAY(GxB_Option_Field field, double *value); extern GrB_Info GxB_Global_Option_set_FUNCTION(GxB_Option_Field field, void *value); extern GrB_Info GxB_Global_Option_set_INT32(GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Global_Option_set_INT64_ARRAY(GxB_Option_Field field, int64_t *value); extern GrB_Info GxB_deserialize_type_name(char *type_name, const void *blob, GrB_Index blob_size); 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 *)); /* descriptor */ extern GrB_Info GxB_Desc_get(GrB_Descriptor desc, GrB_Desc_Field field, ...); extern GrB_Info GxB_Desc_get_FP64(GrB_Descriptor desc, GrB_Desc_Field field, double *value); extern GrB_Info GxB_Desc_get_INT32(GrB_Descriptor desc, GrB_Desc_Field field, int32_t *value); extern GrB_Info GxB_Desc_set(GrB_Descriptor desc, GrB_Desc_Field field, ...); extern GrB_Info GxB_Desc_set_FP64(GrB_Descriptor desc, GrB_Desc_Field field, double value); extern GrB_Info GxB_Desc_set_INT32(GrB_Descriptor desc, GrB_Desc_Field field, int32_t value); 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); /* indexunary */ extern GrB_Info GxB_IndexUnaryOp_fprint(GrB_IndexUnaryOp op, const char *name, GxB_Print_Level pr, FILE *f); extern 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); extern GrB_Info GxB_IndexUnaryOp_xtype_name(char *type_name, const GrB_IndexUnaryOp op); extern GrB_Info GxB_IndexUnaryOp_ytype_name(char *type_name, const GrB_IndexUnaryOp op); extern GrB_Info GxB_IndexUnaryOp_ztype_name(char *type_name, const GrB_IndexUnaryOp op); /* iterator */ extern GrB_Index GxB_Matrix_Iterator_getp(GxB_Iterator iterator); extern GrB_Index GxB_Matrix_Iterator_getpmax(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getIndex(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getp(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getpmax(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_getColIndex(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_getRowIndex(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_kount(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_getColIndex(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_getRowIndex(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_kount(GxB_Iterator iterator); extern GrB_Info GxB_Iterator_free(GxB_Iterator *iterator); extern GrB_Info GxB_Iterator_new(GxB_Iterator *iterator); extern GrB_Info GxB_Matrix_Iterator_next(GxB_Iterator iterator); extern GrB_Info GxB_Matrix_Iterator_seek(GxB_Iterator iterator, GrB_Index p); extern GrB_Info GxB_Vector_Iterator_next(GxB_Iterator iterator); extern GrB_Info GxB_Vector_Iterator_seek(GxB_Iterator iterator, GrB_Index p); extern GrB_Info GxB_colIterator_kseek(GxB_Iterator iterator, GrB_Index k); extern GrB_Info GxB_colIterator_nextCol(GxB_Iterator iterator); extern GrB_Info GxB_colIterator_nextRow(GxB_Iterator iterator); extern GrB_Info GxB_colIterator_seekCol(GxB_Iterator iterator, GrB_Index col); extern GrB_Info GxB_rowIterator_kseek(GxB_Iterator iterator, GrB_Index k); extern GrB_Info GxB_rowIterator_nextCol(GxB_Iterator iterator); extern GrB_Info GxB_rowIterator_nextRow(GxB_Iterator iterator); extern GrB_Info GxB_rowIterator_seekRow(GxB_Iterator iterator, GrB_Index row); extern GxB_FC32_t GxB_Iterator_get_FC32(GxB_Iterator iterator); extern GxB_FC64_t GxB_Iterator_get_FC64(GxB_Iterator iterator); extern bool GxB_Iterator_get_BOOL(GxB_Iterator iterator); extern double GxB_Iterator_get_FP64(GxB_Iterator iterator); extern float GxB_Iterator_get_FP32(GxB_Iterator iterator); extern int8_t GxB_Iterator_get_INT8(GxB_Iterator iterator); extern int16_t GxB_Iterator_get_INT16(GxB_Iterator iterator); extern int32_t GxB_Iterator_get_INT32(GxB_Iterator iterator); extern int64_t GxB_Iterator_get_INT64(GxB_Iterator iterator); extern uint8_t GxB_Iterator_get_UINT8(GxB_Iterator iterator); extern uint16_t GxB_Iterator_get_UINT16(GxB_Iterator iterator); extern uint32_t GxB_Iterator_get_UINT32(GxB_Iterator iterator); extern uint64_t GxB_Iterator_get_UINT64(GxB_Iterator iterator); extern void GxB_Iterator_get_UDT(GxB_Iterator iterator, void *value); extern void GxB_Matrix_Iterator_getIndex(GxB_Iterator iterator, GrB_Index *row, GrB_Index *col); /* 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_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_Matrix_Option_get(GrB_Matrix A, GxB_Option_Field field, ...); extern GrB_Info GxB_Matrix_Option_get_FP64(GrB_Matrix A, GxB_Option_Field field, double *value); extern GrB_Info GxB_Matrix_Option_get_INT32(GrB_Matrix A, GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Matrix_Option_set(GrB_Matrix A, GxB_Option_Field field, ...); extern GrB_Info GxB_Matrix_Option_set_FP64(GrB_Matrix A, GxB_Option_Field field, double value); extern GrB_Info GxB_Matrix_Option_set_INT32(GrB_Matrix A, GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Matrix_apply_BinaryOp1st(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); 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 GrB_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_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); extern 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); 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_build_Scalar(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, GrB_Scalar scalar, GrB_Index nvals); extern GrB_Info GxB_Matrix_concat(GrB_Matrix C, const GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); extern 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); 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, bool *iso, 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, bool *iso, 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 *iso, 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 *iso, bool *jumbled, const GrB_Descriptor desc); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool iso, 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, bool iso, 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 iso, 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 iso, bool jumbled, const GrB_Descriptor desc); extern 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, GrB_Format format); extern 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, GrB_Format format); 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, bool iso, 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, bool iso, 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, bool iso, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_isStoredElement(const GrB_Matrix A, GrB_Index i, GrB_Index j); extern GrB_Info GxB_Matrix_iso(bool *iso, const GrB_Matrix A); extern GrB_Info GxB_Matrix_memoryUsage(size_t *size, const GrB_Matrix A); extern GrB_Info GxB_Matrix_pack_BitmapC(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_BitmapR(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_CSC(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ai_size, GrB_Index Ax_size, bool iso, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_CSR(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Aj_size, GrB_Index Ax_size, bool iso, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_FullC(GrB_Matrix A, void **Ax, GrB_Index Ax_size, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_FullR(GrB_Matrix A, void **Ax, GrB_Index Ax_size, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_HyperCSC(GrB_Matrix A, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_HyperCSR(GrB_Matrix A, 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, bool iso, 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_reshape(GrB_Matrix C, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); extern 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); 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 GrB_Scalar Thunk, const GrB_Descriptor desc); extern 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); extern 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); extern GrB_Info GxB_Matrix_serialize(void **blob_handle, GrB_Index *blob_size_handle, GrB_Matrix A, 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_sort(GrB_Matrix C, GrB_Matrix P, GrB_BinaryOp op, GrB_Matrix A, const GrB_Descriptor desc); extern 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); 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_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GrB_Scalar 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_Matrix_type_name(char *type_name, const GrB_Matrix A); extern GrB_Info GxB_Matrix_unpack_BitmapC(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_BitmapR(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_CSC(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ai_size, GrB_Index *Ax_size, bool *iso, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_CSR(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Aj_size, GrB_Index *Ax_size, bool *iso, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_FullC(GrB_Matrix A, void **Ax, GrB_Index *Ax_size, bool *iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_FullR(GrB_Matrix A, void **Ax, GrB_Index *Ax_size, bool *iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_HyperCSC(GrB_Matrix A, 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, bool *iso, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_HyperCSR(GrB_Matrix A, 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, bool *iso, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); 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); extern GrB_Info GxB_Vector_diag(GrB_Vector v, const GrB_Matrix A, int64_t k, const GrB_Descriptor desc); extern GrB_Info GxB_colIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_pack_HyperHash(GrB_Matrix A, GrB_Matrix *Y, const GrB_Descriptor desc); extern GrB_Info GxB_rowIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_unpack_HyperHash(GrB_Matrix A, GrB_Matrix *Y, 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(GrB_Scalar s); extern GrB_Info GxB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); extern GrB_Info GxB_Scalar_error(const char **error, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FC32(GxB_FC32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FC64(GxB_FC64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_fprint(GrB_Scalar s, const char *name, GxB_Print_Level pr, FILE *f); extern GrB_Info GxB_Scalar_free(GrB_Scalar *s); extern GrB_Info GxB_Scalar_memoryUsage(size_t *size, const GrB_Scalar s); extern GrB_Info GxB_Scalar_new(GrB_Scalar *s, GrB_Type type); extern GrB_Info GxB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); extern GrB_Info GxB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); extern GrB_Info GxB_Scalar_setElement_FC32(GrB_Scalar s, GxB_FC32_t x); extern GrB_Info GxB_Scalar_setElement_FC64(GrB_Scalar s, GxB_FC64_t x); extern GrB_Info GxB_Scalar_setElement_FP32(GrB_Scalar s, float x); extern GrB_Info GxB_Scalar_setElement_FP64(GrB_Scalar s, double x); extern GrB_Info GxB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); extern GrB_Info GxB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); extern GrB_Info GxB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); extern GrB_Info GxB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); extern GrB_Info GxB_Scalar_setElement_UDT(GrB_Scalar s, void *x); extern GrB_Info GxB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); extern GrB_Info GxB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); extern GrB_Info GxB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); extern GrB_Info GxB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); extern GrB_Info GxB_Scalar_type(GrB_Type *type, const GrB_Scalar s); extern GrB_Info GxB_Scalar_type_name(char *type_name, const GrB_Scalar s); extern GrB_Info GxB_Scalar_wait(GrB_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, GrB_WaitMode waitmode); 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_from_name(GrB_Type *type, const char *type_name); extern GrB_Info GxB_Type_name(char *type_name, const GrB_Type type); extern GrB_Info GxB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *type_name, const char *type_defn); extern GrB_Info GxB_Type_size(size_t *size, const 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_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn); extern GrB_Info GxB_UnaryOp_xtype(GrB_Type *xtype, GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_xtype_name(char *type_name, const GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_ztype(GrB_Type *ztype, GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_ztype_name(char *type_name, const GrB_UnaryOp unaryop); /* vector */ extern GrB_Info GxB_Vector_Iterator_attach(GxB_Iterator iterator, GrB_Vector v, GrB_Descriptor desc); extern GrB_Info GxB_Vector_Option_get(GrB_Vector A, GxB_Option_Field field, ...); extern GrB_Info GxB_Vector_Option_get_FP64(GrB_Vector v, GxB_Option_Field field, double *value); extern GrB_Info GxB_Vector_Option_get_INT32(GrB_Vector v, GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Vector_Option_set(GrB_Vector A, GxB_Option_Field field, ...); extern GrB_Info GxB_Vector_Option_set_FP64(GrB_Vector v, GxB_Option_Field field, double value); extern GrB_Info GxB_Vector_Option_set_INT32(GrB_Vector v, GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Vector_apply_BinaryOp1st(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); 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 GrB_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_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); extern 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); 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_build_Scalar(GrB_Vector w, const GrB_Index *I, GrB_Scalar scalar, GrB_Index nvals); extern GrB_Info GxB_Vector_deserialize(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); extern 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); 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool iso, 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, bool iso, 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, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_isStoredElement(const GrB_Vector v, GrB_Index i); extern GrB_Info GxB_Vector_iso(bool *iso, const GrB_Vector v); extern GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); extern GrB_Info GxB_Vector_pack_Bitmap(GrB_Vector v, int8_t **vb, void **vx, GrB_Index vb_size, GrB_Index vx_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_pack_CSC(GrB_Vector v, GrB_Index **vi, void **vx, GrB_Index vi_size, GrB_Index vx_size, bool iso, GrB_Index nvals, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_pack_Full(GrB_Vector v, void **vx, GrB_Index vx_size, bool iso, 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 GrB_Scalar Thunk, const GrB_Descriptor desc); extern 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); extern 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); extern GrB_Info GxB_Vector_serialize(void **blob_handle, GrB_Index *blob_size_handle, GrB_Vector u, 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_sort(GrB_Vector w, GrB_Vector p, GrB_BinaryOp op, GrB_Vector u, 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_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_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GrB_Scalar 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); extern GrB_Info GxB_Vector_type_name(char *type_name, const GrB_Vector v); extern GrB_Info GxB_Vector_unpack_Bitmap(GrB_Vector v, int8_t **vb, void **vx, GrB_Index *vb_size, GrB_Index *vx_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_unpack_CSC(GrB_Vector v, GrB_Index **vi, void **vx, GrB_Index *vi_size, GrB_Index *vx_size, bool *iso, GrB_Index *nvals, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_unpack_Full(GrB_Vector v, void **vx, GrB_Index *vx_size, bool *iso, 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_INTEL ... #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_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_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 ... /* 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; python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/suitesparse_graphblas_arm64.h000066400000000000000000006172411435240002400316620ustar00rootroot00000000000000/* This file is automatically generated */ /* GrB typedefs */ typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; typedef struct GB_Descriptor_opaque *GrB_Descriptor; 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_Iterator_opaque *GxB_Iterator; 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_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 *); /* 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, GxB_COMPRESSION = 36, GxB_IMPORT = 37 } 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, GxB_SECURE_IMPORT = 502 } 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 = 2, 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_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 } GrB_Info; typedef enum { GrB_NONBLOCKING = 0, GrB_BLOCKING = 1, GxB_NONBLOCKING_GPU = 2, GxB_BLOCKING_GPU = 3 } GrB_Mode; typedef enum { GrB_COMPLETE = 0, GrB_MATERIALIZE = 1 } GrB_WaitMode; /* 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_COMPILER_VERSION = 23, GxB_COMPILER_NAME = 24, GxB_LIBRARY_OPENMP = 25, GxB_GLOBAL_NTHREADS = 5, GxB_GLOBAL_CHUNK = 7, GxB_BURBLE = 99, GxB_PRINTF = 101, GxB_FLUSH = 102, GxB_MEMORY_POOL = 103, GxB_PRINT_1BASED = 104, 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_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_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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* indexunary */ extern GrB_Info GrB_IndexUnaryOp_error(const char **error, const GrB_IndexUnaryOp op); extern GrB_Info GrB_IndexUnaryOp_free(GrB_IndexUnaryOp *op); extern GrB_Info GrB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); extern GrB_Info GrB_IndexUnaryOp_wait(GrB_IndexUnaryOp op, GrB_WaitMode waitmode); /* 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_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); 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_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); 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GrB_Scalar 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_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size); extern GrB_Info GrB_Matrix_diag(GrB_Matrix *C, const GrB_Vector v, int64_t k); 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_exportHint(GrB_Format *format, GrB_Matrix A); extern GrB_Info GrB_Matrix_exportSize(GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, 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_Scalar(GrB_Scalar 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_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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); 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_BinaryOp_Scalar(GrB_Scalar S, 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_Monoid_Scalar(GrB_Scalar c, 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern GrB_Info GrB_Matrix_serialize(void *blob, GrB_Index *blob_size_handle, GrB_Matrix A); extern GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size_handle, GrB_Matrix A); 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_Scalar(GrB_Matrix C, GrB_Scalar 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, GrB_WaitMode waitmode); 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, GrB_WaitMode waitmode); /* scalar */ extern GrB_Info GrB_Scalar_clear(GrB_Scalar s); extern GrB_Info GrB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); extern GrB_Info GrB_Scalar_error(const char **error, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_free(GrB_Scalar *s); extern GrB_Info GrB_Scalar_new(GrB_Scalar *s, GrB_Type type); extern GrB_Info GrB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); extern GrB_Info GrB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); extern GrB_Info GrB_Scalar_setElement_FP32(GrB_Scalar s, float x); extern GrB_Info GrB_Scalar_setElement_FP64(GrB_Scalar s, double x); extern GrB_Info GrB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); extern GrB_Info GrB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); extern GrB_Info GrB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); extern GrB_Info GrB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); extern GrB_Info GrB_Scalar_setElement_UDT(GrB_Scalar s, void *x); extern GrB_Info GrB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); extern GrB_Info GrB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); extern GrB_Info GrB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); extern GrB_Info GrB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); extern GrB_Info GrB_Scalar_wait(GrB_Scalar s, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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_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); 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_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); 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GrB_Scalar 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_Scalar(GrB_Scalar 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_BinaryOp_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_BinaryOp op, 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_Monoid_Scalar(GrB_Scalar 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Vector w, GrB_Scalar 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, GrB_WaitMode waitmode); /*************** * 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 *binop_name); /* iterator */ extern GrB_Info GB_Iterator_rc_bitmap_next(GxB_Iterator iterator); extern GrB_Info GB_Iterator_rc_seek(GxB_Iterator iterator, GrB_Index j, bool jth_vector); extern GrB_Info GB_Vector_Iterator_bitmap_seek(GxB_Iterator iterator, GrB_Index unused); /* matrix */ extern GrB_Info GB_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GxB_Format_Value format, GrB_Descriptor desc); /* 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 *type_name); /* unary */ extern GrB_Info GB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_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_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); extern GrB_Info GxB_BinaryOp_xtype(GrB_Type *xtype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_xtype_name(char *type_name, const GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ytype(GrB_Type *ytype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ytype_name(char *type_name, const GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ztype(GrB_Type *ztype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ztype_name(char *type_name, const GrB_BinaryOp binaryop); /* core */ extern GrB_Info GxB_Global_Option_get(GxB_Option_Field field, char *); extern GrB_Info GxB_Global_Option_get_CHAR(GxB_Option_Field field, char **value); extern GrB_Info GxB_Global_Option_get_FP64(GxB_Option_Field field, double *value); extern GrB_Info GxB_Global_Option_get_FUNCTION(GxB_Option_Field field, void **value); extern GrB_Info GxB_Global_Option_get_INT32(GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Global_Option_get_INT64(GxB_Option_Field field, int64_t *value); extern GrB_Info GxB_Global_Option_set(GxB_Option_Field field, char *); extern GrB_Info GxB_Global_Option_set_FP64(GxB_Option_Field field, double value); extern GrB_Info GxB_Global_Option_set_FP64_ARRAY(GxB_Option_Field field, double *value); extern GrB_Info GxB_Global_Option_set_FUNCTION(GxB_Option_Field field, void *value); extern GrB_Info GxB_Global_Option_set_INT32(GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Global_Option_set_INT64_ARRAY(GxB_Option_Field field, int64_t *value); extern GrB_Info GxB_deserialize_type_name(char *type_name, const void *blob, GrB_Index blob_size); 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 *)); /* descriptor */ extern GrB_Info GxB_Desc_get(GrB_Descriptor desc, GrB_Desc_Field field, char *); extern GrB_Info GxB_Desc_get_FP64(GrB_Descriptor desc, GrB_Desc_Field field, double *value); extern GrB_Info GxB_Desc_get_INT32(GrB_Descriptor desc, GrB_Desc_Field field, int32_t *value); extern GrB_Info GxB_Desc_set(GrB_Descriptor desc, GrB_Desc_Field field, char *); extern GrB_Info GxB_Desc_set_FP64(GrB_Descriptor desc, GrB_Desc_Field field, double value); extern GrB_Info GxB_Desc_set_INT32(GrB_Descriptor desc, GrB_Desc_Field field, int32_t value); 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); /* indexunary */ extern GrB_Info GxB_IndexUnaryOp_fprint(GrB_IndexUnaryOp op, const char *name, GxB_Print_Level pr, FILE *f); extern 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); extern GrB_Info GxB_IndexUnaryOp_xtype_name(char *type_name, const GrB_IndexUnaryOp op); extern GrB_Info GxB_IndexUnaryOp_ytype_name(char *type_name, const GrB_IndexUnaryOp op); extern GrB_Info GxB_IndexUnaryOp_ztype_name(char *type_name, const GrB_IndexUnaryOp op); /* iterator */ extern GrB_Index GxB_Matrix_Iterator_getp(GxB_Iterator iterator); extern GrB_Index GxB_Matrix_Iterator_getpmax(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getIndex(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getp(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getpmax(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_getColIndex(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_getRowIndex(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_kount(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_getColIndex(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_getRowIndex(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_kount(GxB_Iterator iterator); extern GrB_Info GxB_Iterator_free(GxB_Iterator *iterator); extern GrB_Info GxB_Iterator_new(GxB_Iterator *iterator); extern GrB_Info GxB_Matrix_Iterator_next(GxB_Iterator iterator); extern GrB_Info GxB_Matrix_Iterator_seek(GxB_Iterator iterator, GrB_Index p); extern GrB_Info GxB_Vector_Iterator_next(GxB_Iterator iterator); extern GrB_Info GxB_Vector_Iterator_seek(GxB_Iterator iterator, GrB_Index p); extern GrB_Info GxB_colIterator_kseek(GxB_Iterator iterator, GrB_Index k); extern GrB_Info GxB_colIterator_nextCol(GxB_Iterator iterator); extern GrB_Info GxB_colIterator_nextRow(GxB_Iterator iterator); extern GrB_Info GxB_colIterator_seekCol(GxB_Iterator iterator, GrB_Index col); extern GrB_Info GxB_rowIterator_kseek(GxB_Iterator iterator, GrB_Index k); extern GrB_Info GxB_rowIterator_nextCol(GxB_Iterator iterator); extern GrB_Info GxB_rowIterator_nextRow(GxB_Iterator iterator); extern GrB_Info GxB_rowIterator_seekRow(GxB_Iterator iterator, GrB_Index row); extern GxB_FC32_t GxB_Iterator_get_FC32(GxB_Iterator iterator); extern GxB_FC64_t GxB_Iterator_get_FC64(GxB_Iterator iterator); extern bool GxB_Iterator_get_BOOL(GxB_Iterator iterator); extern double GxB_Iterator_get_FP64(GxB_Iterator iterator); extern float GxB_Iterator_get_FP32(GxB_Iterator iterator); extern int8_t GxB_Iterator_get_INT8(GxB_Iterator iterator); extern int16_t GxB_Iterator_get_INT16(GxB_Iterator iterator); extern int32_t GxB_Iterator_get_INT32(GxB_Iterator iterator); extern int64_t GxB_Iterator_get_INT64(GxB_Iterator iterator); extern uint8_t GxB_Iterator_get_UINT8(GxB_Iterator iterator); extern uint16_t GxB_Iterator_get_UINT16(GxB_Iterator iterator); extern uint32_t GxB_Iterator_get_UINT32(GxB_Iterator iterator); extern uint64_t GxB_Iterator_get_UINT64(GxB_Iterator iterator); extern void GxB_Iterator_get_UDT(GxB_Iterator iterator, void *value); extern void GxB_Matrix_Iterator_getIndex(GxB_Iterator iterator, GrB_Index *row, GrB_Index *col); /* 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_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_Matrix_Option_get(GrB_Matrix A, GxB_Option_Field field, char *); extern GrB_Info GxB_Matrix_Option_get_FP64(GrB_Matrix A, GxB_Option_Field field, double *value); extern GrB_Info GxB_Matrix_Option_get_INT32(GrB_Matrix A, GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Matrix_Option_set(GrB_Matrix A, GxB_Option_Field field, char *); extern GrB_Info GxB_Matrix_Option_set_FP64(GrB_Matrix A, GxB_Option_Field field, double value); extern GrB_Info GxB_Matrix_Option_set_INT32(GrB_Matrix A, GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Matrix_apply_BinaryOp1st(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); 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 GrB_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_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); extern 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); 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_build_Scalar(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, GrB_Scalar scalar, GrB_Index nvals); extern GrB_Info GxB_Matrix_concat(GrB_Matrix C, const GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); extern 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); 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, bool *iso, 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, bool *iso, 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 *iso, 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 *iso, bool *jumbled, const GrB_Descriptor desc); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool iso, 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, bool iso, 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 iso, 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 iso, bool jumbled, const GrB_Descriptor desc); extern 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, GrB_Format format); extern 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, GrB_Format format); 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, bool iso, 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, bool iso, 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, bool iso, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_isStoredElement(const GrB_Matrix A, GrB_Index i, GrB_Index j); extern GrB_Info GxB_Matrix_iso(bool *iso, const GrB_Matrix A); extern GrB_Info GxB_Matrix_memoryUsage(size_t *size, const GrB_Matrix A); extern GrB_Info GxB_Matrix_pack_BitmapC(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_BitmapR(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_CSC(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ai_size, GrB_Index Ax_size, bool iso, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_CSR(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Aj_size, GrB_Index Ax_size, bool iso, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_FullC(GrB_Matrix A, void **Ax, GrB_Index Ax_size, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_FullR(GrB_Matrix A, void **Ax, GrB_Index Ax_size, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_HyperCSC(GrB_Matrix A, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_HyperCSR(GrB_Matrix A, 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, bool iso, 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_reshape(GrB_Matrix C, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); extern 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); 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 GrB_Scalar Thunk, const GrB_Descriptor desc); extern 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); extern 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); extern GrB_Info GxB_Matrix_serialize(void **blob_handle, GrB_Index *blob_size_handle, GrB_Matrix A, 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_sort(GrB_Matrix C, GrB_Matrix P, GrB_BinaryOp op, GrB_Matrix A, const GrB_Descriptor desc); extern 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); 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_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GrB_Scalar 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_Matrix_type_name(char *type_name, const GrB_Matrix A); extern GrB_Info GxB_Matrix_unpack_BitmapC(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_BitmapR(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_CSC(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ai_size, GrB_Index *Ax_size, bool *iso, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_CSR(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Aj_size, GrB_Index *Ax_size, bool *iso, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_FullC(GrB_Matrix A, void **Ax, GrB_Index *Ax_size, bool *iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_FullR(GrB_Matrix A, void **Ax, GrB_Index *Ax_size, bool *iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_HyperCSC(GrB_Matrix A, 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, bool *iso, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_HyperCSR(GrB_Matrix A, 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, bool *iso, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); 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); extern GrB_Info GxB_Vector_diag(GrB_Vector v, const GrB_Matrix A, int64_t k, const GrB_Descriptor desc); extern GrB_Info GxB_colIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_pack_HyperHash(GrB_Matrix A, GrB_Matrix *Y, const GrB_Descriptor desc); extern GrB_Info GxB_rowIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_unpack_HyperHash(GrB_Matrix A, GrB_Matrix *Y, 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(GrB_Scalar s); extern GrB_Info GxB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); extern GrB_Info GxB_Scalar_error(const char **error, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FC32(GxB_FC32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FC64(GxB_FC64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_fprint(GrB_Scalar s, const char *name, GxB_Print_Level pr, FILE *f); extern GrB_Info GxB_Scalar_free(GrB_Scalar *s); extern GrB_Info GxB_Scalar_memoryUsage(size_t *size, const GrB_Scalar s); extern GrB_Info GxB_Scalar_new(GrB_Scalar *s, GrB_Type type); extern GrB_Info GxB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); extern GrB_Info GxB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); extern GrB_Info GxB_Scalar_setElement_FC32(GrB_Scalar s, GxB_FC32_t x); extern GrB_Info GxB_Scalar_setElement_FC64(GrB_Scalar s, GxB_FC64_t x); extern GrB_Info GxB_Scalar_setElement_FP32(GrB_Scalar s, float x); extern GrB_Info GxB_Scalar_setElement_FP64(GrB_Scalar s, double x); extern GrB_Info GxB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); extern GrB_Info GxB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); extern GrB_Info GxB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); extern GrB_Info GxB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); extern GrB_Info GxB_Scalar_setElement_UDT(GrB_Scalar s, void *x); extern GrB_Info GxB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); extern GrB_Info GxB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); extern GrB_Info GxB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); extern GrB_Info GxB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); extern GrB_Info GxB_Scalar_type(GrB_Type *type, const GrB_Scalar s); extern GrB_Info GxB_Scalar_type_name(char *type_name, const GrB_Scalar s); extern GrB_Info GxB_Scalar_wait(GrB_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, GrB_WaitMode waitmode); 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_from_name(GrB_Type *type, const char *type_name); extern GrB_Info GxB_Type_name(char *type_name, const GrB_Type type); extern GrB_Info GxB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *type_name, const char *type_defn); extern GrB_Info GxB_Type_size(size_t *size, const 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_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn); extern GrB_Info GxB_UnaryOp_xtype(GrB_Type *xtype, GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_xtype_name(char *type_name, const GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_ztype(GrB_Type *ztype, GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_ztype_name(char *type_name, const GrB_UnaryOp unaryop); /* vector */ extern GrB_Info GxB_Vector_Iterator_attach(GxB_Iterator iterator, GrB_Vector v, GrB_Descriptor desc); extern GrB_Info GxB_Vector_Option_get(GrB_Vector A, GxB_Option_Field field, char *); extern GrB_Info GxB_Vector_Option_get_FP64(GrB_Vector v, GxB_Option_Field field, double *value); extern GrB_Info GxB_Vector_Option_get_INT32(GrB_Vector v, GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Vector_Option_set(GrB_Vector A, GxB_Option_Field field, char *); extern GrB_Info GxB_Vector_Option_set_FP64(GrB_Vector v, GxB_Option_Field field, double value); extern GrB_Info GxB_Vector_Option_set_INT32(GrB_Vector v, GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Vector_apply_BinaryOp1st(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); 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 GrB_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_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); extern 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); 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_build_Scalar(GrB_Vector w, const GrB_Index *I, GrB_Scalar scalar, GrB_Index nvals); extern GrB_Info GxB_Vector_deserialize(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); extern 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); 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool iso, 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, bool iso, 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, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_isStoredElement(const GrB_Vector v, GrB_Index i); extern GrB_Info GxB_Vector_iso(bool *iso, const GrB_Vector v); extern GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); extern GrB_Info GxB_Vector_pack_Bitmap(GrB_Vector v, int8_t **vb, void **vx, GrB_Index vb_size, GrB_Index vx_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_pack_CSC(GrB_Vector v, GrB_Index **vi, void **vx, GrB_Index vi_size, GrB_Index vx_size, bool iso, GrB_Index nvals, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_pack_Full(GrB_Vector v, void **vx, GrB_Index vx_size, bool iso, 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 GrB_Scalar Thunk, const GrB_Descriptor desc); extern 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); extern 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); extern GrB_Info GxB_Vector_serialize(void **blob_handle, GrB_Index *blob_size_handle, GrB_Vector u, 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_sort(GrB_Vector w, GrB_Vector p, GrB_BinaryOp op, GrB_Vector u, 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_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_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GrB_Scalar 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); extern GrB_Info GxB_Vector_type_name(char *type_name, const GrB_Vector v); extern GrB_Info GxB_Vector_unpack_Bitmap(GrB_Vector v, int8_t **vb, void **vx, GrB_Index *vb_size, GrB_Index *vx_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_unpack_CSC(GrB_Vector v, GrB_Index **vi, void **vx, GrB_Index *vi_size, GrB_Index *vx_size, bool *iso, GrB_Index *nvals, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_unpack_Full(GrB_Vector v, void **vx, GrB_Index *vx_size, bool *iso, 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_INTEL ... #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_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_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 ... /* 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; python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/suitesparse_graphblas_no_complex.h000066400000000000000000005613421435240002400330740ustar00rootroot00000000000000/* This file is automatically generated */ /* GrB typedefs */ typedef struct GB_BinaryOp_opaque *GrB_BinaryOp; typedef struct GB_Descriptor_opaque *GrB_Descriptor; 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_Iterator_opaque *GxB_Iterator; 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_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 *); /* 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, GxB_COMPRESSION = 36, GxB_IMPORT = 37 } 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, GxB_SECURE_IMPORT = 502 } 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 = 2, 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_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 } GrB_Info; typedef enum { GrB_NONBLOCKING = 0, GrB_BLOCKING = 1, GxB_NONBLOCKING_GPU = 2, GxB_BLOCKING_GPU = 3 } GrB_Mode; typedef enum { GrB_COMPLETE = 0, GrB_MATERIALIZE = 1 } GrB_WaitMode; /* 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_COMPILER_VERSION = 23, GxB_COMPILER_NAME = 24, GxB_LIBRARY_OPENMP = 25, GxB_GLOBAL_NTHREADS = 5, GxB_GLOBAL_CHUNK = 7, GxB_BURBLE = 99, GxB_PRINTF = 101, GxB_FLUSH = 102, GxB_MEMORY_POOL = 103, GxB_PRINT_1BASED = 104, 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_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_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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* indexunary */ extern GrB_Info GrB_IndexUnaryOp_error(const char **error, const GrB_IndexUnaryOp op); extern GrB_Info GrB_IndexUnaryOp_free(GrB_IndexUnaryOp *op); extern GrB_Info GrB_IndexUnaryOp_new(GrB_IndexUnaryOp *op, GxB_index_unary_function function, GrB_Type ztype, GrB_Type xtype, GrB_Type ytype); extern GrB_Info GrB_IndexUnaryOp_wait(GrB_IndexUnaryOp op, GrB_WaitMode waitmode); /* 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_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); 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_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); 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GrB_Scalar 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_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size); extern GrB_Info GrB_Matrix_diag(GrB_Matrix *C, const GrB_Vector v, int64_t k); 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_exportHint(GrB_Format *format, GrB_Matrix A); extern GrB_Info GrB_Matrix_exportSize(GrB_Index *Ap_len, GrB_Index *Ai_len, GrB_Index *Ax_len, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, GrB_Matrix A); extern 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, GrB_Format format, 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_Scalar(GrB_Scalar 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_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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); extern 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, GrB_Format format); 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_BinaryOp_Scalar(GrB_Scalar S, 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_Monoid_Scalar(GrB_Scalar c, 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern GrB_Info GrB_Matrix_serialize(void *blob, GrB_Index *blob_size_handle, GrB_Matrix A); extern GrB_Info GrB_Matrix_serializeSize(GrB_Index *blob_size_handle, GrB_Matrix A); 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_Scalar(GrB_Matrix C, GrB_Scalar 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, GrB_WaitMode waitmode); 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, GrB_WaitMode waitmode); /* scalar */ extern GrB_Info GrB_Scalar_clear(GrB_Scalar s); extern GrB_Info GrB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); extern GrB_Info GrB_Scalar_error(const char **error, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); extern GrB_Info GrB_Scalar_free(GrB_Scalar *s); extern GrB_Info GrB_Scalar_new(GrB_Scalar *s, GrB_Type type); extern GrB_Info GrB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); extern GrB_Info GrB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); extern GrB_Info GrB_Scalar_setElement_FP32(GrB_Scalar s, float x); extern GrB_Info GrB_Scalar_setElement_FP64(GrB_Scalar s, double x); extern GrB_Info GrB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); extern GrB_Info GrB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); extern GrB_Info GrB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); extern GrB_Info GrB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); extern GrB_Info GrB_Scalar_setElement_UDT(GrB_Scalar s, void *x); extern GrB_Info GrB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); extern GrB_Info GrB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); extern GrB_Info GrB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); extern GrB_Info GrB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); extern GrB_Info GrB_Scalar_wait(GrB_Scalar s, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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, GrB_WaitMode waitmode); /* 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_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); 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_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); 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GrB_Scalar 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_Scalar(GrB_Scalar 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_BinaryOp_Scalar(GrB_Scalar c, const GrB_BinaryOp accum, const GrB_BinaryOp op, 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_Monoid_Scalar(GrB_Scalar 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_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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); extern 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); 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_Scalar(GrB_Vector w, GrB_Scalar 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, GrB_WaitMode waitmode); /*************** * 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 *binop_name); /* iterator */ extern GrB_Info GB_Iterator_rc_bitmap_next(GxB_Iterator iterator); extern GrB_Info GB_Iterator_rc_seek(GxB_Iterator iterator, GrB_Index j, bool jth_vector); extern GrB_Info GB_Vector_Iterator_bitmap_seek(GxB_Iterator iterator, GrB_Index unused); /* matrix */ extern GrB_Info GB_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GxB_Format_Value format, GrB_Descriptor desc); /* 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 *type_name); /* unary */ extern GrB_Info GB_UnaryOp_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_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_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); extern GrB_Info GxB_BinaryOp_xtype(GrB_Type *xtype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_xtype_name(char *type_name, const GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ytype(GrB_Type *ytype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ytype_name(char *type_name, const GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ztype(GrB_Type *ztype, GrB_BinaryOp binaryop); extern GrB_Info GxB_BinaryOp_ztype_name(char *type_name, const GrB_BinaryOp binaryop); /* core */ extern GrB_Info GxB_Global_Option_get(GxB_Option_Field field, ...); extern GrB_Info GxB_Global_Option_get_CHAR(GxB_Option_Field field, char **value); extern GrB_Info GxB_Global_Option_get_FP64(GxB_Option_Field field, double *value); extern GrB_Info GxB_Global_Option_get_FUNCTION(GxB_Option_Field field, void **value); extern GrB_Info GxB_Global_Option_get_INT32(GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Global_Option_get_INT64(GxB_Option_Field field, int64_t *value); extern GrB_Info GxB_Global_Option_set(GxB_Option_Field field, ...); extern GrB_Info GxB_Global_Option_set_FP64(GxB_Option_Field field, double value); extern GrB_Info GxB_Global_Option_set_FP64_ARRAY(GxB_Option_Field field, double *value); extern GrB_Info GxB_Global_Option_set_FUNCTION(GxB_Option_Field field, void *value); extern GrB_Info GxB_Global_Option_set_INT32(GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Global_Option_set_INT64_ARRAY(GxB_Option_Field field, int64_t *value); extern GrB_Info GxB_deserialize_type_name(char *type_name, const void *blob, GrB_Index blob_size); 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 *)); /* descriptor */ extern GrB_Info GxB_Desc_get(GrB_Descriptor desc, GrB_Desc_Field field, ...); extern GrB_Info GxB_Desc_get_FP64(GrB_Descriptor desc, GrB_Desc_Field field, double *value); extern GrB_Info GxB_Desc_get_INT32(GrB_Descriptor desc, GrB_Desc_Field field, int32_t *value); extern GrB_Info GxB_Desc_set(GrB_Descriptor desc, GrB_Desc_Field field, ...); extern GrB_Info GxB_Desc_set_FP64(GrB_Descriptor desc, GrB_Desc_Field field, double value); extern GrB_Info GxB_Desc_set_INT32(GrB_Descriptor desc, GrB_Desc_Field field, int32_t value); 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); /* indexunary */ extern GrB_Info GxB_IndexUnaryOp_fprint(GrB_IndexUnaryOp op, const char *name, GxB_Print_Level pr, FILE *f); extern 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); extern GrB_Info GxB_IndexUnaryOp_xtype_name(char *type_name, const GrB_IndexUnaryOp op); extern GrB_Info GxB_IndexUnaryOp_ytype_name(char *type_name, const GrB_IndexUnaryOp op); extern GrB_Info GxB_IndexUnaryOp_ztype_name(char *type_name, const GrB_IndexUnaryOp op); /* iterator */ extern GrB_Index GxB_Matrix_Iterator_getp(GxB_Iterator iterator); extern GrB_Index GxB_Matrix_Iterator_getpmax(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getIndex(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getp(GxB_Iterator iterator); extern GrB_Index GxB_Vector_Iterator_getpmax(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_getColIndex(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_getRowIndex(GxB_Iterator iterator); extern GrB_Index GxB_colIterator_kount(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_getColIndex(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_getRowIndex(GxB_Iterator iterator); extern GrB_Index GxB_rowIterator_kount(GxB_Iterator iterator); extern GrB_Info GxB_Iterator_free(GxB_Iterator *iterator); extern GrB_Info GxB_Iterator_new(GxB_Iterator *iterator); extern GrB_Info GxB_Matrix_Iterator_next(GxB_Iterator iterator); extern GrB_Info GxB_Matrix_Iterator_seek(GxB_Iterator iterator, GrB_Index p); extern GrB_Info GxB_Vector_Iterator_next(GxB_Iterator iterator); extern GrB_Info GxB_Vector_Iterator_seek(GxB_Iterator iterator, GrB_Index p); extern GrB_Info GxB_colIterator_kseek(GxB_Iterator iterator, GrB_Index k); extern GrB_Info GxB_colIterator_nextCol(GxB_Iterator iterator); extern GrB_Info GxB_colIterator_nextRow(GxB_Iterator iterator); extern GrB_Info GxB_colIterator_seekCol(GxB_Iterator iterator, GrB_Index col); extern GrB_Info GxB_rowIterator_kseek(GxB_Iterator iterator, GrB_Index k); extern GrB_Info GxB_rowIterator_nextCol(GxB_Iterator iterator); extern GrB_Info GxB_rowIterator_nextRow(GxB_Iterator iterator); extern GrB_Info GxB_rowIterator_seekRow(GxB_Iterator iterator, GrB_Index row); extern bool GxB_Iterator_get_BOOL(GxB_Iterator iterator); extern double GxB_Iterator_get_FP64(GxB_Iterator iterator); extern float GxB_Iterator_get_FP32(GxB_Iterator iterator); extern int8_t GxB_Iterator_get_INT8(GxB_Iterator iterator); extern int16_t GxB_Iterator_get_INT16(GxB_Iterator iterator); extern int32_t GxB_Iterator_get_INT32(GxB_Iterator iterator); extern int64_t GxB_Iterator_get_INT64(GxB_Iterator iterator); extern uint8_t GxB_Iterator_get_UINT8(GxB_Iterator iterator); extern uint16_t GxB_Iterator_get_UINT16(GxB_Iterator iterator); extern uint32_t GxB_Iterator_get_UINT32(GxB_Iterator iterator); extern uint64_t GxB_Iterator_get_UINT64(GxB_Iterator iterator); extern void GxB_Iterator_get_UDT(GxB_Iterator iterator, void *value); extern void GxB_Matrix_Iterator_getIndex(GxB_Iterator iterator, GrB_Index *row, GrB_Index *col); /* 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_Iterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_Matrix_Option_get(GrB_Matrix A, GxB_Option_Field field, ...); extern GrB_Info GxB_Matrix_Option_get_FP64(GrB_Matrix A, GxB_Option_Field field, double *value); extern GrB_Info GxB_Matrix_Option_get_INT32(GrB_Matrix A, GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Matrix_Option_set(GrB_Matrix A, GxB_Option_Field field, ...); extern GrB_Info GxB_Matrix_Option_set_FP64(GrB_Matrix A, GxB_Option_Field field, double value); extern GrB_Info GxB_Matrix_Option_set_INT32(GrB_Matrix A, GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Matrix_apply_BinaryOp1st(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); 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 GrB_Scalar y, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_build_Scalar(GrB_Matrix C, const GrB_Index *I, const GrB_Index *J, GrB_Scalar scalar, GrB_Index nvals); extern GrB_Info GxB_Matrix_concat(GrB_Matrix C, const GrB_Matrix *Tiles, const GrB_Index m, const GrB_Index n, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_deserialize(GrB_Matrix *C, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_diag(GrB_Matrix C, const GrB_Vector v, int64_t k, const GrB_Descriptor desc); extern 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); 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, bool *iso, 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, bool *iso, 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 *iso, 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 *iso, 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool iso, 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, bool iso, 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 iso, 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 iso, 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, bool iso, 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, bool iso, 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, bool iso, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_isStoredElement(const GrB_Matrix A, GrB_Index i, GrB_Index j); extern GrB_Info GxB_Matrix_iso(bool *iso, const GrB_Matrix A); extern GrB_Info GxB_Matrix_memoryUsage(size_t *size, const GrB_Matrix A); extern GrB_Info GxB_Matrix_pack_BitmapC(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_BitmapR(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index Ab_size, GrB_Index Ax_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_CSC(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index Ap_size, GrB_Index Ai_size, GrB_Index Ax_size, bool iso, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_CSR(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index Ap_size, GrB_Index Aj_size, GrB_Index Ax_size, bool iso, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_FullC(GrB_Matrix A, void **Ax, GrB_Index Ax_size, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_FullR(GrB_Matrix A, void **Ax, GrB_Index Ax_size, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_HyperCSC(GrB_Matrix A, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_pack_HyperCSR(GrB_Matrix A, 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, bool iso, GrB_Index nvec, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_reshape(GrB_Matrix C, bool by_col, GrB_Index nrows_new, GrB_Index ncols_new, const GrB_Descriptor desc); extern 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); 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 GrB_Scalar Thunk, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_serialize(void **blob_handle, GrB_Index *blob_size_handle, GrB_Matrix A, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_sort(GrB_Matrix C, GrB_Matrix P, GrB_BinaryOp op, GrB_Matrix A, const GrB_Descriptor desc); extern 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); 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_Scalar(GrB_Matrix C, const GrB_Matrix Mask, const GrB_BinaryOp accum, GrB_Scalar 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_Matrix_type_name(char *type_name, const GrB_Matrix A); extern GrB_Info GxB_Matrix_unpack_BitmapC(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_BitmapR(GrB_Matrix A, int8_t **Ab, void **Ax, GrB_Index *Ab_size, GrB_Index *Ax_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_CSC(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Ai, void **Ax, GrB_Index *Ap_size, GrB_Index *Ai_size, GrB_Index *Ax_size, bool *iso, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_CSR(GrB_Matrix A, GrB_Index **Ap, GrB_Index **Aj, void **Ax, GrB_Index *Ap_size, GrB_Index *Aj_size, GrB_Index *Ax_size, bool *iso, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_FullC(GrB_Matrix A, void **Ax, GrB_Index *Ax_size, bool *iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_FullR(GrB_Matrix A, void **Ax, GrB_Index *Ax_size, bool *iso, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_HyperCSC(GrB_Matrix A, 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, bool *iso, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Matrix_unpack_HyperCSR(GrB_Matrix A, 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, bool *iso, GrB_Index *nvec, bool *jumbled, const GrB_Descriptor desc); 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); extern GrB_Info GxB_Vector_diag(GrB_Vector v, const GrB_Matrix A, int64_t k, const GrB_Descriptor desc); extern GrB_Info GxB_colIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_pack_HyperHash(GrB_Matrix A, GrB_Matrix *Y, const GrB_Descriptor desc); extern GrB_Info GxB_rowIterator_attach(GxB_Iterator iterator, GrB_Matrix A, GrB_Descriptor desc); extern GrB_Info GxB_unpack_HyperHash(GrB_Matrix A, GrB_Matrix *Y, 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(GrB_Scalar s); extern GrB_Info GxB_Scalar_dup(GrB_Scalar *s, const GrB_Scalar t); extern GrB_Info GxB_Scalar_error(const char **error, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_BOOL(bool *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FP32(float *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_FP64(double *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT8(int8_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT16(int16_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT32(int32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_INT64(int64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UDT(void *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT8(uint8_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT16(uint16_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT32(uint32_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_extractElement_UINT64(uint64_t *x, const GrB_Scalar s); extern GrB_Info GxB_Scalar_fprint(GrB_Scalar s, const char *name, GxB_Print_Level pr, FILE *f); extern GrB_Info GxB_Scalar_free(GrB_Scalar *s); extern GrB_Info GxB_Scalar_memoryUsage(size_t *size, const GrB_Scalar s); extern GrB_Info GxB_Scalar_new(GrB_Scalar *s, GrB_Type type); extern GrB_Info GxB_Scalar_nvals(GrB_Index *nvals, const GrB_Scalar s); extern GrB_Info GxB_Scalar_setElement_BOOL(GrB_Scalar s, bool x); extern GrB_Info GxB_Scalar_setElement_FP32(GrB_Scalar s, float x); extern GrB_Info GxB_Scalar_setElement_FP64(GrB_Scalar s, double x); extern GrB_Info GxB_Scalar_setElement_INT8(GrB_Scalar s, int8_t x); extern GrB_Info GxB_Scalar_setElement_INT16(GrB_Scalar s, int16_t x); extern GrB_Info GxB_Scalar_setElement_INT32(GrB_Scalar s, int32_t x); extern GrB_Info GxB_Scalar_setElement_INT64(GrB_Scalar s, int64_t x); extern GrB_Info GxB_Scalar_setElement_UDT(GrB_Scalar s, void *x); extern GrB_Info GxB_Scalar_setElement_UINT8(GrB_Scalar s, uint8_t x); extern GrB_Info GxB_Scalar_setElement_UINT16(GrB_Scalar s, uint16_t x); extern GrB_Info GxB_Scalar_setElement_UINT32(GrB_Scalar s, uint32_t x); extern GrB_Info GxB_Scalar_setElement_UINT64(GrB_Scalar s, uint64_t x); extern GrB_Info GxB_Scalar_type(GrB_Type *type, const GrB_Scalar s); extern GrB_Info GxB_Scalar_type_name(char *type_name, const GrB_Scalar s); extern GrB_Info GxB_Scalar_wait(GrB_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, GrB_WaitMode waitmode); 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_from_name(GrB_Type *type, const char *type_name); extern GrB_Info GxB_Type_name(char *type_name, const GrB_Type type); extern GrB_Info GxB_Type_new(GrB_Type *type, size_t sizeof_ctype, const char *type_name, const char *type_defn); extern GrB_Info GxB_Type_size(size_t *size, const 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_new(GrB_UnaryOp *unaryop, GxB_unary_function function, GrB_Type ztype, GrB_Type xtype, const char *unop_name, const char *unop_defn); extern GrB_Info GxB_UnaryOp_xtype(GrB_Type *xtype, GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_xtype_name(char *type_name, const GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_ztype(GrB_Type *ztype, GrB_UnaryOp unaryop); extern GrB_Info GxB_UnaryOp_ztype_name(char *type_name, const GrB_UnaryOp unaryop); /* vector */ extern GrB_Info GxB_Vector_Iterator_attach(GxB_Iterator iterator, GrB_Vector v, GrB_Descriptor desc); extern GrB_Info GxB_Vector_Option_get(GrB_Vector A, GxB_Option_Field field, ...); extern GrB_Info GxB_Vector_Option_get_FP64(GrB_Vector v, GxB_Option_Field field, double *value); extern GrB_Info GxB_Vector_Option_get_INT32(GrB_Vector v, GxB_Option_Field field, int32_t *value); extern GrB_Info GxB_Vector_Option_set(GrB_Vector A, GxB_Option_Field field, ...); extern GrB_Info GxB_Vector_Option_set_FP64(GrB_Vector v, GxB_Option_Field field, double value); extern GrB_Info GxB_Vector_Option_set_INT32(GrB_Vector v, GxB_Option_Field field, int32_t value); extern GrB_Info GxB_Vector_apply_BinaryOp1st(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); 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 GrB_Scalar y, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_build_Scalar(GrB_Vector w, const GrB_Index *I, GrB_Scalar scalar, GrB_Index nvals); extern GrB_Info GxB_Vector_deserialize(GrB_Vector *w, GrB_Type type, const void *blob, GrB_Index blob_size, const GrB_Descriptor desc); extern 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); 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, bool *iso, 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, bool *iso, 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, bool *iso, 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, bool iso, 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, bool iso, 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, bool iso, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_isStoredElement(const GrB_Vector v, GrB_Index i); extern GrB_Info GxB_Vector_iso(bool *iso, const GrB_Vector v); extern GrB_Info GxB_Vector_memoryUsage(size_t *size, const GrB_Vector v); extern GrB_Info GxB_Vector_pack_Bitmap(GrB_Vector v, int8_t **vb, void **vx, GrB_Index vb_size, GrB_Index vx_size, bool iso, GrB_Index nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_pack_CSC(GrB_Vector v, GrB_Index **vi, void **vx, GrB_Index vi_size, GrB_Index vx_size, bool iso, GrB_Index nvals, bool jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_pack_Full(GrB_Vector v, void **vx, GrB_Index vx_size, bool iso, 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 GrB_Scalar Thunk, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_serialize(void **blob_handle, GrB_Index *blob_size_handle, GrB_Vector u, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_sort(GrB_Vector w, GrB_Vector p, GrB_BinaryOp op, GrB_Vector u, 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_Scalar(GrB_Vector w, const GrB_Vector mask, const GrB_BinaryOp accum, GrB_Scalar 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); extern GrB_Info GxB_Vector_type_name(char *type_name, const GrB_Vector v); extern GrB_Info GxB_Vector_unpack_Bitmap(GrB_Vector v, int8_t **vb, void **vx, GrB_Index *vb_size, GrB_Index *vx_size, bool *iso, GrB_Index *nvals, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_unpack_CSC(GrB_Vector v, GrB_Index **vi, void **vx, GrB_Index *vi_size, GrB_Index *vx_size, bool *iso, GrB_Index *nvals, bool *jumbled, const GrB_Descriptor desc); extern GrB_Info GxB_Vector_unpack_Full(GrB_Vector v, void **vx, GrB_Index *vx_size, bool *iso, 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_INTEL ... #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_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_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 ... /* 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; python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/000077500000000000000000000000001435240002400252355ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/__init__.py000066400000000000000000000000001435240002400273340ustar00rootroot00000000000000python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/conftest.py000066400000000000000000000002451435240002400274350ustar00rootroot00000000000000import pytest from suitesparse_graphblas import initialize @pytest.fixture(scope="session", autouse=True) def intialize_suitesparse_graphblas(): initialize() python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/test_doctest.py000066400000000000000000000004031435240002400303100ustar00rootroot00000000000000def 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) python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/test_exceptions.py000066400000000000000000000005621435240002400310320ustar00rootroot00000000000000import 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) python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/test_initialize.py000066400000000000000000000004531435240002400310110ustar00rootroot00000000000000if __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() python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/test_io.py000066400000000000000000000142441435240002400272620ustar00rootroot00000000000000import 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] python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/test_package.py000066400000000000000000000001741435240002400302430ustar00rootroot00000000000000from suitesparse_graphblas import ffi, lib # noqa def test_matrix_existence(): assert hasattr(lib, "GrB_Matrix_new") python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/tests/test_scalar.py000066400000000000000000000005731435240002400301200ustar00rootroot00000000000000import pytest from suitesparse_graphblas import ffi, lib, supports_complex # noqa @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 python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/utils.pxd000066400000000000000000000026001435240002400257460ustar00rootroot00000000000000from 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) python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/utils.pyx000066400000000000000000000055221435240002400260010ustar00rootroot00000000000000import 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) python-suitesparse-graphblas-7.4.0.0/suitesparse_graphblas/vector.py000066400000000000000000000043441435240002400257540ustar00rootroot00000000000000from suitesparse_graphblas import check_status, ffi, lib from .io.serialize import deserialize_vector as deserialize # noqa from .io.serialize import serialize_vector as serialize # noqa 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] python-suitesparse-graphblas-7.4.0.0/versioneer.py000066400000000000000000002337351435240002400222510ustar00rootroot00000000000000# Version: 0.21 """The Versioneer - like a rocketeer, but for versions. The Versioneer ============== * like a rocketeer, but for versions! * https://github.com/python-versioneer/python-versioneer * Brian Warner * License: Public Domain * Compatible with: Python 3.6, 3.7, 3.8, 3.9 and pypy3 * [![Latest Version][pypi-image]][pypi-url] * [![Build Status][travis-image]][travis-url] This is a tool for managing a recorded version number in distutils-based python projects. The goal is to remove the tedious and error-prone "update the embedded version string" step from your release process. Making a new release should be as easy as recording a new tag in your version-control system, and maybe making new tarballs. ## Quick Install * `pip install versioneer` to somewhere in your $PATH * add a `[versioneer]` section to your setup.cfg (see [Install](INSTALL.md)) * run `versioneer install` in your source tree, commit the results * Verify version information with `python setup.py version` ## Version Identifiers Source trees come from a variety of places: * a version-control system checkout (mostly used by developers) * a nightly tarball, produced by build automation * a snapshot tarball, produced by a web-based VCS browser, like github's "tarball from tag" feature * a release tarball, produced by "setup.py sdist", distributed through PyPI Within each source tree, the version identifier (either a string or a number, this tool is format-agnostic) can come from a variety of places: * ask the VCS tool itself, e.g. "git describe" (for checkouts), which knows about recent "tags" and an absolute revision-id * the name of the directory into which the tarball was unpacked * an expanded VCS keyword ($Id$, etc) * a `_version.py` created by some earlier build step For released software, the version identifier is closely related to a VCS tag. Some projects use tag names that include more than just the version string (e.g. "myproject-1.2" instead of just "1.2"), in which case the tool needs to strip the tag prefix to extract the version identifier. For unreleased software (between tags), the version identifier should provide enough information to help developers recreate the same tree, while also giving them an idea of roughly how old the tree is (after version 1.2, before version 1.3). Many VCS systems can report a description that captures this, for example `git describe --tags --dirty --always` reports things like "0.7-1-g574ab98-dirty" to indicate that the checkout is one revision past the 0.7 tag, has a unique revision id of "574ab98", and is "dirty" (it has uncommitted changes). The version identifier is used for multiple purposes: * to allow the module to self-identify its version: `myproject.__version__` * to choose a name and prefix for a 'setup.py sdist' tarball ## Theory of Operation Versioneer works by adding a special `_version.py` file into your source tree, where your `__init__.py` can import it. This `_version.py` knows how to dynamically ask the VCS tool for version information at import time. `_version.py` also contains `$Revision$` markers, and the installation process marks `_version.py` to have this marker rewritten with a tag name during the `git archive` command. As a result, generated tarballs will contain enough information to get the proper version. To allow `setup.py` to compute a version too, a `versioneer.py` is added to the top level of your source tree, next to `setup.py` and the `setup.cfg` that configures it. This overrides several distutils/setuptools commands to compute the version when invoked, and changes `setup.py build` and `setup.py sdist` to replace `_version.py` with a small static file that contains just the generated version data. ## Installation See [INSTALL.md](./INSTALL.md) for detailed installation instructions. ## Version-String Flavors Code which uses Versioneer can learn about its version string at runtime by importing `_version` from your main `__init__.py` file and running the `get_versions()` function. From the "outside" (e.g. in `setup.py`), you can import the top-level `versioneer.py` and run `get_versions()`. Both functions return a dictionary with different flavors of version information: * `['version']`: A condensed version string, rendered using the selected style. This is the most commonly used value for the project's version string. The default "pep440" style yields strings like `0.11`, `0.11+2.g1076c97`, or `0.11+2.g1076c97.dirty`. See the "Styles" section below for alternative styles. * `['full-revisionid']`: detailed revision identifier. For Git, this is the full SHA1 commit id, e.g. "1076c978a8d3cfc70f408fe5974aa6c092c949ac". * `['date']`: Date and time of the latest `HEAD` commit. For Git, it is the commit date in ISO 8601 format. This will be None if the date is not available. * `['dirty']`: a boolean, True if the tree has uncommitted changes. Note that this is only accurate if run in a VCS checkout, otherwise it is likely to be False or None * `['error']`: if the version string could not be computed, this will be set to a string describing the problem, otherwise it will be None. It may be useful to throw an exception in setup.py if this is set, to avoid e.g. creating tarballs with a version string of "unknown". Some variants are more useful than others. Including `full-revisionid` in a bug report should allow developers to reconstruct the exact code being tested (or indicate the presence of local changes that should be shared with the developers). `version` is suitable for display in an "about" box or a CLI `--version` output: it can be easily compared against release notes and lists of bugs fixed in various releases. The installer adds the following text to your `__init__.py` to place a basic version in `YOURPROJECT.__version__`: from ._version import get_versions __version__ = get_versions()['version'] del get_versions ## Styles The setup.cfg `style=` configuration controls how the VCS information is rendered into a version string. The default style, "pep440", produces a PEP440-compliant string, equal to the un-prefixed tag name for actual releases, and containing an additional "local version" section with more detail for in-between builds. For Git, this is TAG[+DISTANCE.gHEX[.dirty]] , using information from `git describe --tags --dirty --always`. For example "0.11+2.g1076c97.dirty" indicates that the tree is like the "1076c97" commit but has uncommitted changes (".dirty"), and that this commit is two revisions ("+2") beyond the "0.11" tag. For released software (exactly equal to a known tag), the identifier will only contain the stripped tag, e.g. "0.11". Other styles are available. See [details.md](details.md) in the Versioneer source tree for descriptions. ## Debugging Versioneer tries to avoid fatal errors: if something goes wrong, it will tend to return a version of "0+unknown". To investigate the problem, run `setup.py version`, which will run the version-lookup code in a verbose mode, and will display the full contents of `get_versions()` (including the `error` string, which may help identify what went wrong). ## Known Limitations Some situations are known to cause problems for Versioneer. This details the most significant ones. More can be found on Github [issues page](https://github.com/python-versioneer/python-versioneer/issues). ### Subprojects Versioneer has limited support for source trees in which `setup.py` is not in the root directory (e.g. `setup.py` and `.git/` are *not* siblings). The are two common reasons why `setup.py` might not be in the root: * Source trees which contain multiple subprojects, such as [Buildbot](https://github.com/buildbot/buildbot), which contains both "master" and "slave" subprojects, each with their own `setup.py`, `setup.cfg`, and `tox.ini`. Projects like these produce multiple PyPI distributions (and upload multiple independently-installable tarballs). * Source trees whose main purpose is to contain a C library, but which also provide bindings to Python (and perhaps other languages) in subdirectories. Versioneer will look for `.git` in parent directories, and most operations should get the right version string. However `pip` and `setuptools` have bugs and implementation details which frequently cause `pip install .` from a subproject directory to fail to find a correct version string (so it usually defaults to `0+unknown`). `pip install --editable .` should work correctly. `setup.py install` might work too. Pip-8.1.1 is known to have this problem, but hopefully it will get fixed in some later version. [Bug #38](https://github.com/python-versioneer/python-versioneer/issues/38) is tracking this issue. The discussion in [PR #61](https://github.com/python-versioneer/python-versioneer/pull/61) describes the issue from the Versioneer side in more detail. [pip PR#3176](https://github.com/pypa/pip/pull/3176) and [pip PR#3615](https://github.com/pypa/pip/pull/3615) contain work to improve pip to let Versioneer work correctly. Versioneer-0.16 and earlier only looked for a `.git` directory next to the `setup.cfg`, so subprojects were completely unsupported with those releases. ### Editable installs with setuptools <= 18.5 `setup.py develop` and `pip install --editable .` allow you to install a project into a virtualenv once, then continue editing the source code (and test) without re-installing after every change. "Entry-point scripts" (`setup(entry_points={"console_scripts": ..})`) are a convenient way to specify executable scripts that should be installed along with the python package. These both work as expected when using modern setuptools. When using setuptools-18.5 or earlier, however, certain operations will cause `pkg_resources.DistributionNotFound` errors when running the entrypoint script, which must be resolved by re-installing the package. This happens when the install happens with one version, then the egg_info data is regenerated while a different version is checked out. Many setup.py commands cause egg_info to be rebuilt (including `sdist`, `wheel`, and installing into a different virtualenv), so this can be surprising. [Bug #83](https://github.com/python-versioneer/python-versioneer/issues/83) describes this one, but upgrading to a newer version of setuptools should probably resolve it. ## Updating Versioneer To upgrade your project to a new release of Versioneer, do the following: * install the new Versioneer (`pip install -U versioneer` or equivalent) * edit `setup.cfg`, if necessary, to include any new configuration settings indicated by the release notes. See [UPGRADING](./UPGRADING.md) for details. * re-run `versioneer install` in your source tree, to replace `SRC/_version.py` * commit any changed files ## Future Directions This tool is designed to make it easily extended to other version-control systems: all VCS-specific components are in separate directories like src/git/ . The top-level `versioneer.py` script is assembled from these components by running make-versioneer.py . In the future, make-versioneer.py will take a VCS name as an argument, and will construct a version of `versioneer.py` that is specific to the given VCS. It might also take the configuration arguments that are currently provided manually during installation by editing setup.py . Alternatively, it might go the other direction and include code from all supported VCS systems, reducing the number of intermediate scripts. ## Similar projects * [setuptools_scm](https://github.com/pypa/setuptools_scm/) - a non-vendored build-time dependency * [minver](https://github.com/jbweston/miniver) - a lightweight reimplementation of versioneer * [versioningit](https://github.com/jwodder/versioningit) - a PEP 518-based setuptools plugin ## License To make Versioneer easier to embed, all its code is dedicated to the public domain. The `_version.py` that it creates is also in the public domain. Specifically, both are released under the Creative Commons "Public Domain Dedication" license (CC0-1.0), as described in https://creativecommons.org/publicdomain/zero/1.0/ . [pypi-image]: https://img.shields.io/pypi/v/versioneer.svg [pypi-url]: https://pypi.python.org/pypi/versioneer/ [travis-image]: https://img.shields.io/travis/com/python-versioneer/python-versioneer.svg [travis-url]: https://travis-ci.com/github/python-versioneer/python-versioneer """ # pylint:disable=invalid-name,import-outside-toplevel,missing-function-docstring # pylint:disable=missing-class-docstring,too-many-branches,too-many-statements # pylint:disable=raise-missing-from,too-many-lines,too-many-locals,import-error # pylint:disable=too-few-public-methods,redefined-outer-name,consider-using-with # pylint:disable=attribute-defined-outside-init,too-many-arguments import configparser import errno import json import os import re import subprocess import sys from typing import Callable, Dict class VersioneerConfig: """Container for Versioneer configuration parameters.""" def get_root(): """Get the project root directory. We require that all commands are run from the project root, i.e. the directory that contains setup.py, setup.cfg, and versioneer.py . """ root = os.path.realpath(os.path.abspath(os.getcwd())) setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): # allow 'python path/to/setup.py COMMAND' root = os.path.dirname(os.path.realpath(os.path.abspath(sys.argv[0]))) setup_py = os.path.join(root, "setup.py") versioneer_py = os.path.join(root, "versioneer.py") if not (os.path.exists(setup_py) or os.path.exists(versioneer_py)): err = ( "Versioneer was unable to run the project root directory. " "Versioneer requires setup.py to be executed from " "its immediate directory (like 'python setup.py COMMAND'), " "or in a way that lets it use sys.argv[0] to find the root " "(like 'python path/to/setup.py COMMAND')." ) raise VersioneerBadRootError(err) try: # Certain runtime workflows (setup.py install/develop in a setuptools # tree) execute all dependencies in a single python process, so # "versioneer" may be imported multiple times, and python's shared # module-import table will cache the first one. So we can't use # os.path.dirname(__file__), as that will find whichever # versioneer.py was first imported, even in later projects. my_path = os.path.realpath(os.path.abspath(__file__)) me_dir = os.path.normcase(os.path.splitext(my_path)[0]) vsr_dir = os.path.normcase(os.path.splitext(versioneer_py)[0]) if me_dir != vsr_dir: print( "Warning: build in %s is using versioneer.py from %s" % (os.path.dirname(my_path), versioneer_py) ) except NameError: pass return root def get_config_from_root(root): """Read the project setup.cfg file to determine Versioneer config.""" # This might raise OSError (if setup.cfg is missing), or # configparser.NoSectionError (if it lacks a [versioneer] section), or # configparser.NoOptionError (if it lacks "VCS="). See the docstring at # the top of versioneer.py for instructions on writing your setup.cfg . setup_cfg = os.path.join(root, "setup.cfg") parser = configparser.ConfigParser() with open(setup_cfg) as cfg_file: parser.read_file(cfg_file) VCS = parser.get("versioneer", "VCS") # mandatory # Dict-like interface for non-mandatory entries section = parser["versioneer"] cfg = VersioneerConfig() cfg.VCS = VCS cfg.style = section.get("style", "") cfg.versionfile_source = section.get("versionfile_source") cfg.versionfile_build = section.get("versionfile_build") cfg.tag_prefix = section.get("tag_prefix") if cfg.tag_prefix in ("''", '""'): cfg.tag_prefix = "" cfg.parentdir_prefix = section.get("parentdir_prefix") cfg.verbose = section.get("verbose") return cfg class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" # these dictionaries contain VCS-specific tools LONG_VERSION_PY: Dict[str, str] = {} HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator """Create decorator to mark a method as the handler of a VCS.""" def decorate(f): """Store f in HANDLERS[vcs][method].""" HANDLERS.setdefault(vcs, {})[method] = f return f return decorate def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) process = None for command in commands: try: dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git process = subprocess.Popen( [command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None), ) break except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %s" % dispcmd) print(e) return None, None else: if verbose: print(f"unable to find command, tried {commands}") return None, None stdout = process.communicate()[0].strip().decode() if process.returncode != 0: if verbose: print("unable to run %s (error)" % dispcmd) print("stdout was %s" % stdout) return None, process.returncode return stdout, process.returncode LONG_VERSION_PY[ "git" ] = r''' # This file helps to compute a version number in source trees obtained from # git-archive tarball (such as those provided by githubs download-from-tag # feature). Distribution tarballs (built by setup.py sdist) and build # directories (produced by setup.py build) will contain a much shorter file # that just contains the computed version number. # This file is released into the public domain. Generated by # versioneer-0.21 (https://github.com/python-versioneer/python-versioneer) """Git implementation of _version.py.""" import errno import os import re import subprocess import sys from typing import Callable, Dict def get_keywords(): """Get the keywords needed to look up the version information.""" # these strings will be replaced by git during git-archive. # setup.py/versioneer.py will grep for the variable names, so they must # each be defined on a line of their own. _version.py will just call # get_keywords(). git_refnames = "%(DOLLAR)sFormat:%%d%(DOLLAR)s" git_full = "%(DOLLAR)sFormat:%%H%(DOLLAR)s" git_date = "%(DOLLAR)sFormat:%%ci%(DOLLAR)s" keywords = {"refnames": git_refnames, "full": git_full, "date": git_date} return keywords class VersioneerConfig: """Container for Versioneer configuration parameters.""" def get_config(): """Create, populate and return the VersioneerConfig() object.""" # these strings are filled in when 'setup.py versioneer' creates # _version.py cfg = VersioneerConfig() cfg.VCS = "git" cfg.style = "%(STYLE)s" cfg.tag_prefix = "%(TAG_PREFIX)s" cfg.parentdir_prefix = "%(PARENTDIR_PREFIX)s" cfg.versionfile_source = "%(VERSIONFILE_SOURCE)s" cfg.verbose = False return cfg class NotThisMethod(Exception): """Exception raised if a method is not valid for the current scenario.""" LONG_VERSION_PY: Dict[str, str] = {} HANDLERS: Dict[str, Dict[str, Callable]] = {} def register_vcs_handler(vcs, method): # decorator """Create decorator to mark a method as the handler of a VCS.""" def decorate(f): """Store f in HANDLERS[vcs][method].""" if vcs not in HANDLERS: HANDLERS[vcs] = {} HANDLERS[vcs][method] = f return f return decorate def run_command(commands, args, cwd=None, verbose=False, hide_stderr=False, env=None): """Call the given command(s).""" assert isinstance(commands, list) process = None for command in commands: try: dispcmd = str([command] + args) # remember shell=False, so use git.cmd on windows, not just git process = subprocess.Popen([command] + args, cwd=cwd, env=env, stdout=subprocess.PIPE, stderr=(subprocess.PIPE if hide_stderr else None)) break except OSError: e = sys.exc_info()[1] if e.errno == errno.ENOENT: continue if verbose: print("unable to run %%s" %% dispcmd) print(e) return None, None else: if verbose: print("unable to find command, tried %%s" %% (commands,)) return None, None stdout = process.communicate()[0].strip().decode() if process.returncode != 0: if verbose: print("unable to run %%s (error)" %% dispcmd) print("stdout was %%s" %% stdout) return None, process.returncode return stdout, process.returncode def versions_from_parentdir(parentdir_prefix, root, verbose): """Try to determine the version from the parent directory name. Source tarballs conventionally unpack into a directory that includes both the project name and a version string. We will also support searching up two directory levels for an appropriately named parent directory """ rootdirs = [] for _ in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): return {"version": dirname[len(parentdir_prefix):], "full-revisionid": None, "dirty": False, "error": None, "date": None} rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: print("Tried directories %%s but none started with prefix %%s" %% (str(rootdirs), parentdir_prefix)) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") @register_vcs_handler("git", "get_keywords") def git_get_keywords(versionfile_abs): """Extract version information from the given file.""" # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: with open(versionfile_abs, "r") as fobj: for line in fobj: if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) if line.strip().startswith("git_date ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) except OSError: pass return keywords @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" if "refnames" not in keywords: raise NotThisMethod("Short version file found") date = keywords.get("date") if date is not None: # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] # git-2.2.0 added "%%cI", which expands to an ISO-8601 -compliant # datestamp. However we prefer "%%ci" (which expands to an "ISO-8601 # -like" string, which we must then edit to make compliant), because # it's been around since git-1.5.3, and it's too difficult to # discover which version we're using, or to work around using an # older one. date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = {r[len(TAG):] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %%d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = {r for r in refs if re.search(r'\d', r)} if verbose: print("discarding '%%s', no digits" %% ",".join(refs - tags)) if verbose: print("likely tags: %%s" %% ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix):] # Filter out refs that exactly match prefix or that don't start # with a number once the prefix is stripped (mostly a concern # when prefix is '') if not re.match(r'\d', r): continue if verbose: print("picking %%s" %% r) return {"version": r, "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None, "date": date} # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return {"version": "0+unknown", "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags", "date": None} @register_vcs_handler("git", "pieces_from_vcs") def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* expanded, and _version.py hasn't already been rewritten with a short version string, meaning we're inside a checked out source tree. """ GITS = ["git"] TAG_PREFIX_REGEX = "*" if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] TAG_PREFIX_REGEX = r"\*" _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) if rc != 0: if verbose: print("Directory %%s not under git control" %% root) raise NotThisMethod("'git rev-parse --git-dir' returned error") # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) describe_out, rc = runner(GITS, ["describe", "--tags", "--dirty", "--always", "--long", "--match", "%%s%%s" %% (tag_prefix, TAG_PREFIX_REGEX)], cwd=root) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() pieces = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) # --abbrev-ref was added in git-1.6.3 if rc != 0 or branch_name is None: raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") branch_name = branch_name.strip() if branch_name == "HEAD": # If we aren't exactly on a branch, pick a branch which represents # the current commit. If all else fails, we are on a branchless # commit. branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) # --contains was added in git-1.5.4 if rc != 0 or branches is None: raise NotThisMethod("'git branch --contains' returned error") branches = branches.split("\n") # Remove the first line if we're running detached if "(" in branches[0]: branches.pop(0) # Strip off the leading "* " from the list of branches. branches = [branch[2:] for branch in branches] if "master" in branches: branch_name = "master" elif not branches: branch_name = None else: # Pick the first branch that is returned. Good or bad. branch_name = branches[0] pieces["branch"] = branch_name # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out # look for -dirty suffix dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: git_describe = git_describe[:git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX mo = re.search(r'^(.+)-(\d+)-g([0-9a-f]+)$', git_describe) if not mo: # unparsable. Maybe git-describe is misbehaving? pieces["error"] = ("unable to parse git-describe output: '%%s'" %% describe_out) return pieces # tag full_tag = mo.group(1) if not full_tag.startswith(tag_prefix): if verbose: fmt = "tag '%%s' doesn't start with prefix '%%s'" print(fmt %% (full_tag, tag_prefix)) pieces["error"] = ("tag '%%s' doesn't start with prefix '%%s'" %% (full_tag, tag_prefix)) return pieces pieces["closest-tag"] = full_tag[len(tag_prefix):] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) # commit: short hex revision ID pieces["short"] = mo.group(3) else: # HEX: no tags pieces["closest-tag"] = None count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() date = runner(GITS, ["show", "-s", "--format=%%ci", "HEAD"], cwd=root)[0].strip() # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces def plus_or_dot(pieces): """Return a + if we don't already have one, else return a .""" if "+" in pieces.get("closest-tag", ""): return "." return "+" def render_pep440(pieces): """Build up version string, with post-release "local version identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty Exceptions: 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += plus_or_dot(pieces) rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0+untagged.%%d.g%%s" %% (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_branch(pieces): """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . The ".dev0" means not master branch. Note that .dev0 sorts backwards (a feature branch will appear "older" than the master branch). Exceptions: 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: if pieces["branch"] != "master": rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "%%d.g%%s" %% (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0" if pieces["branch"] != "master": rendered += ".dev0" rendered += "+untagged.%%d.g%%s" %% (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def pep440_split_post(ver): """Split pep440 version string at the post-release segment. Returns the release segments before the post-release and the post-release version number (or -1 if no post-release segment is present). """ vc = str.split(ver, ".post") return vc[0], int(vc[1] or 0) if len(vc) == 2 else None def render_pep440_pre(pieces): """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: if pieces["distance"]: # update the post release segment tag_version, post_version = pep440_split_post(pieces["closest-tag"]) rendered = tag_version if post_version is not None: rendered += ".post%%d.dev%%d" %% (post_version+1, pieces["distance"]) else: rendered += ".post0.dev%%d" %% (pieces["distance"]) else: # no commits, use the tag as the version rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%%d" %% pieces["distance"] return rendered def render_pep440_post(pieces): """TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that .dev0 sorts backwards (a dirty tree will appear "older" than the corresponding clean one), but you shouldn't be releasing software with -dirty anyways. Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%%s" %% pieces["short"] else: # exception #1 rendered = "0.post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += "+g%%s" %% pieces["short"] return rendered def render_pep440_post_branch(pieces): """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . The ".dev0" means not master branch. Exceptions: 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%%d" %% pieces["distance"] if pieces["branch"] != "master": rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%%s" %% pieces["short"] if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0.post%%d" %% pieces["distance"] if pieces["branch"] != "master": rendered += ".dev0" rendered += "+g%%s" %% pieces["short"] if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" else: # exception #1 rendered = "0.post%%d" %% pieces["distance"] if pieces["dirty"]: rendered += ".dev0" return rendered def render_git_describe(pieces): """TAG[-DISTANCE-gHEX][-dirty]. Like 'git describe --tags --dirty --always'. Exceptions: 1: no tags. HEX[-dirty] (note: no 'g' prefix) """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render_git_describe_long(pieces): """TAG-DISTANCE-gHEX[-dirty]. Like 'git describe --tags --dirty --always -long'. The distance/hash is unconditional. Exceptions: 1: no tags. HEX[-dirty] (note: no 'g' prefix) """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] rendered += "-%%d-g%%s" %% (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: return {"version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"], "date": None} if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) elif style == "pep440-branch": rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) elif style == "pep440-post-branch": rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": rendered = render_git_describe(pieces) elif style == "git-describe-long": rendered = render_git_describe_long(pieces) else: raise ValueError("unknown style '%%s'" %% style) return {"version": rendered, "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None, "date": pieces.get("date")} def get_versions(): """Get version information or return default if unable to do so.""" # I am in _version.py, which lives at ROOT/VERSIONFILE_SOURCE. If we have # __file__, we can work backwards from there to the root. Some # py2exe/bbfreeze/non-CPython implementations don't do __file__, in which # case we can only use expanded keywords. cfg = get_config() verbose = cfg.verbose try: return git_versions_from_keywords(get_keywords(), cfg.tag_prefix, verbose) except NotThisMethod: pass try: root = os.path.realpath(__file__) # versionfile_source is the relative path from the top of the source # tree (where the .git directory might live) to this file. Invert # this to find the root from __file__. for _ in cfg.versionfile_source.split('/'): root = os.path.dirname(root) except NameError: return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to find root of source tree", "date": None} try: pieces = git_pieces_from_vcs(cfg.tag_prefix, root, verbose) return render(pieces, cfg.style) except NotThisMethod: pass try: if cfg.parentdir_prefix: return versions_from_parentdir(cfg.parentdir_prefix, root, verbose) except NotThisMethod: pass return {"version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to compute version", "date": None} ''' @register_vcs_handler("git", "get_keywords") def git_get_keywords(versionfile_abs): """Extract version information from the given file.""" # the code embedded in _version.py can just fetch the value of these # keywords. When used from setup.py, we don't want to import _version.py, # so we do it with a regexp instead. This function is not used from # _version.py. keywords = {} try: with open(versionfile_abs) as fobj: for line in fobj: if line.strip().startswith("git_refnames ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["refnames"] = mo.group(1) if line.strip().startswith("git_full ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["full"] = mo.group(1) if line.strip().startswith("git_date ="): mo = re.search(r'=\s*"(.*)"', line) if mo: keywords["date"] = mo.group(1) except OSError: pass return keywords @register_vcs_handler("git", "keywords") def git_versions_from_keywords(keywords, tag_prefix, verbose): """Get version information from git keywords.""" if "refnames" not in keywords: raise NotThisMethod("Short version file found") date = keywords.get("date") if date is not None: # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] # git-2.2.0 added "%cI", which expands to an ISO-8601 -compliant # datestamp. However we prefer "%ci" (which expands to an "ISO-8601 # -like" string, which we must then edit to make compliant), because # it's been around since git-1.5.3, and it's too difficult to # discover which version we're using, or to work around using an # older one. date = date.strip().replace(" ", "T", 1).replace(" ", "", 1) refnames = keywords["refnames"].strip() if refnames.startswith("$Format"): if verbose: print("keywords are unexpanded, not using") raise NotThisMethod("unexpanded keywords, not a git-archive tarball") refs = {r.strip() for r in refnames.strip("()").split(",")} # starting in git-1.8.3, tags are listed as "tag: foo-1.0" instead of # just "foo-1.0". If we see a "tag: " prefix, prefer those. TAG = "tag: " tags = {r[len(TAG) :] for r in refs if r.startswith(TAG)} if not tags: # Either we're using git < 1.8.3, or there really are no tags. We use # a heuristic: assume all version tags have a digit. The old git %d # expansion behaves like git log --decorate=short and strips out the # refs/heads/ and refs/tags/ prefixes that would let us distinguish # between branches and tags. By ignoring refnames without digits, we # filter out many common branch names like "release" and # "stabilization", as well as "HEAD" and "master". tags = {r for r in refs if re.search(r"\d", r)} if verbose: print("discarding '%s', no digits" % ",".join(refs - tags)) if verbose: print("likely tags: %s" % ",".join(sorted(tags))) for ref in sorted(tags): # sorting will prefer e.g. "2.0" over "2.0rc1" if ref.startswith(tag_prefix): r = ref[len(tag_prefix) :] # Filter out refs that exactly match prefix or that don't start # with a number once the prefix is stripped (mostly a concern # when prefix is '') if not re.match(r"\d", r): continue if verbose: print("picking %s" % r) return { "version": r, "full-revisionid": keywords["full"].strip(), "dirty": False, "error": None, "date": date, } # no suitable tags, so version is "0+unknown", but full hex is still there if verbose: print("no suitable tags, using unknown + full revision id") return { "version": "0+unknown", "full-revisionid": keywords["full"].strip(), "dirty": False, "error": "no suitable tags", "date": None, } @register_vcs_handler("git", "pieces_from_vcs") def git_pieces_from_vcs(tag_prefix, root, verbose, runner=run_command): """Get version from 'git describe' in the root of the source tree. This only gets called if the git-archive 'subst' keywords were *not* expanded, and _version.py hasn't already been rewritten with a short version string, meaning we're inside a checked out source tree. """ GITS = ["git"] TAG_PREFIX_REGEX = "*" if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] TAG_PREFIX_REGEX = r"\*" _, rc = runner(GITS, ["rev-parse", "--git-dir"], cwd=root, hide_stderr=True) if rc != 0: if verbose: print("Directory %s not under git control" % root) raise NotThisMethod("'git rev-parse --git-dir' returned error") # if there is a tag matching tag_prefix, this yields TAG-NUM-gHEX[-dirty] # if there isn't one, this yields HEX[-dirty] (no NUM) describe_out, rc = runner( GITS, [ "describe", "--tags", "--dirty", "--always", "--long", "--match", f"{tag_prefix}{TAG_PREFIX_REGEX}", ], cwd=root, ) # --long was added in git-1.5.5 if describe_out is None: raise NotThisMethod("'git describe' failed") describe_out = describe_out.strip() full_out, rc = runner(GITS, ["rev-parse", "HEAD"], cwd=root) if full_out is None: raise NotThisMethod("'git rev-parse' failed") full_out = full_out.strip() pieces = {} pieces["long"] = full_out pieces["short"] = full_out[:7] # maybe improved later pieces["error"] = None branch_name, rc = runner(GITS, ["rev-parse", "--abbrev-ref", "HEAD"], cwd=root) # --abbrev-ref was added in git-1.6.3 if rc != 0 or branch_name is None: raise NotThisMethod("'git rev-parse --abbrev-ref' returned error") branch_name = branch_name.strip() if branch_name == "HEAD": # If we aren't exactly on a branch, pick a branch which represents # the current commit. If all else fails, we are on a branchless # commit. branches, rc = runner(GITS, ["branch", "--contains"], cwd=root) # --contains was added in git-1.5.4 if rc != 0 or branches is None: raise NotThisMethod("'git branch --contains' returned error") branches = branches.split("\n") # Remove the first line if we're running detached if "(" in branches[0]: branches.pop(0) # Strip off the leading "* " from the list of branches. branches = [branch[2:] for branch in branches] if "master" in branches: branch_name = "master" elif not branches: branch_name = None else: # Pick the first branch that is returned. Good or bad. branch_name = branches[0] pieces["branch"] = branch_name # parse describe_out. It will be like TAG-NUM-gHEX[-dirty] or HEX[-dirty] # TAG might have hyphens. git_describe = describe_out # look for -dirty suffix dirty = git_describe.endswith("-dirty") pieces["dirty"] = dirty if dirty: git_describe = git_describe[: git_describe.rindex("-dirty")] # now we have TAG-NUM-gHEX or HEX if "-" in git_describe: # TAG-NUM-gHEX mo = re.search(r"^(.+)-(\d+)-g([0-9a-f]+)$", git_describe) if not mo: # unparsable. Maybe git-describe is misbehaving? pieces["error"] = "unable to parse git-describe output: '%s'" % describe_out return pieces # tag full_tag = mo.group(1) if not full_tag.startswith(tag_prefix): if verbose: fmt = "tag '%s' doesn't start with prefix '%s'" print(fmt % (full_tag, tag_prefix)) pieces["error"] = f"tag '{full_tag}' doesn't start with prefix '{tag_prefix}'" return pieces pieces["closest-tag"] = full_tag[len(tag_prefix) :] # distance: number of commits since tag pieces["distance"] = int(mo.group(2)) # commit: short hex revision ID pieces["short"] = mo.group(3) else: # HEX: no tags pieces["closest-tag"] = None count_out, rc = runner(GITS, ["rev-list", "HEAD", "--count"], cwd=root) pieces["distance"] = int(count_out) # total number of commits # commit date: see ISO-8601 comment in git_versions_from_keywords() date = runner(GITS, ["show", "-s", "--format=%ci", "HEAD"], cwd=root)[0].strip() # Use only the last line. Previous lines may contain GPG signature # information. date = date.splitlines()[-1] pieces["date"] = date.strip().replace(" ", "T", 1).replace(" ", "", 1) return pieces def do_vcs_install(manifest_in, versionfile_source, ipy): """Git-specific installation logic for Versioneer. For Git, this means creating/changing .gitattributes to mark _version.py for export-subst keyword substitution. """ GITS = ["git"] if sys.platform == "win32": GITS = ["git.cmd", "git.exe"] files = [manifest_in, versionfile_source] if ipy: files.append(ipy) try: my_path = __file__ if my_path.endswith(".pyc") or my_path.endswith(".pyo"): my_path = os.path.splitext(my_path)[0] + ".py" versioneer_file = os.path.relpath(my_path) except NameError: versioneer_file = "versioneer.py" files.append(versioneer_file) present = False try: with open(".gitattributes") as fobj: for line in fobj: if line.strip().startswith(versionfile_source): if "export-subst" in line.strip().split()[1:]: present = True break except OSError: pass if not present: with open(".gitattributes", "a+") as fobj: fobj.write(f"{versionfile_source} export-subst\n") files.append(".gitattributes") run_command(GITS, ["add", "--"] + files) def versions_from_parentdir(parentdir_prefix, root, verbose): """Try to determine the version from the parent directory name. Source tarballs conventionally unpack into a directory that includes both the project name and a version string. We will also support searching up two directory levels for an appropriately named parent directory """ rootdirs = [] for _ in range(3): dirname = os.path.basename(root) if dirname.startswith(parentdir_prefix): return { "version": dirname[len(parentdir_prefix) :], "full-revisionid": None, "dirty": False, "error": None, "date": None, } rootdirs.append(root) root = os.path.dirname(root) # up a level if verbose: print( "Tried directories %s but none started with prefix %s" % (str(rootdirs), parentdir_prefix) ) raise NotThisMethod("rootdir doesn't start with parentdir_prefix") SHORT_VERSION_PY = """ # This file was generated by 'versioneer.py' (0.21) from # revision-control system data, or from the parent directory name of an # unpacked source archive. Distribution tarballs contain a pre-generated copy # of this file. import json version_json = ''' %s ''' # END VERSION_JSON def get_versions(): return json.loads(version_json) """ def versions_from_file(filename): """Try to determine the version from _version.py if present.""" try: with open(filename) as f: contents = f.read() except OSError: raise NotThisMethod("unable to read _version.py") mo = re.search(r"version_json = '''\n(.*)''' # END VERSION_JSON", contents, re.M | re.S) if not mo: mo = re.search(r"version_json = '''\r\n(.*)''' # END VERSION_JSON", contents, re.M | re.S) if not mo: raise NotThisMethod("no version_json in _version.py") return json.loads(mo.group(1)) def write_to_version_file(filename, versions): """Write the given version number to the given _version.py file.""" os.unlink(filename) contents = json.dumps(versions, sort_keys=True, indent=1, separators=(",", ": ")) with open(filename, "w") as f: f.write(SHORT_VERSION_PY % contents) print("set {} to '{}'".format(filename, versions["version"])) def plus_or_dot(pieces): """Return a + if we don't already have one, else return a .""" if "+" in pieces.get("closest-tag", ""): return "." return "+" def render_pep440(pieces): """Build up version string, with post-release "local version identifier". Our goal: TAG[+DISTANCE.gHEX[.dirty]] . Note that if you get a tagged build and then dirty it, you'll get TAG+0.gHEX.dirty Exceptions: 1: no tags. git_describe was just HEX. 0+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += plus_or_dot(pieces) rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_branch(pieces): """TAG[[.dev0]+DISTANCE.gHEX[.dirty]] . The ".dev0" means not master branch. Note that .dev0 sorts backwards (a feature branch will appear "older" than the master branch). Exceptions: 1: no tags. 0[.dev0]+untagged.DISTANCE.gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: if pieces["branch"] != "master": rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0" if pieces["branch"] != "master": rendered += ".dev0" rendered += "+untagged.%d.g%s" % (pieces["distance"], pieces["short"]) if pieces["dirty"]: rendered += ".dirty" return rendered def pep440_split_post(ver): """Split pep440 version string at the post-release segment. Returns the release segments before the post-release and the post-release version number (or -1 if no post-release segment is present). """ vc = str.split(ver, ".post") return vc[0], int(vc[1] or 0) if len(vc) == 2 else None def render_pep440_pre(pieces): """TAG[.postN.devDISTANCE] -- No -dirty. Exceptions: 1: no tags. 0.post0.devDISTANCE """ if pieces["closest-tag"]: if pieces["distance"]: # update the post release segment tag_version, post_version = pep440_split_post(pieces["closest-tag"]) rendered = tag_version if post_version is not None: rendered += ".post%d.dev%d" % (post_version + 1, pieces["distance"]) else: rendered += ".post0.dev%d" % (pieces["distance"]) else: # no commits, use the tag as the version rendered = pieces["closest-tag"] else: # exception #1 rendered = "0.post0.dev%d" % pieces["distance"] return rendered def render_pep440_post(pieces): """TAG[.postDISTANCE[.dev0]+gHEX] . The ".dev0" means dirty. Note that .dev0 sorts backwards (a dirty tree will appear "older" than the corresponding clean one), but you shouldn't be releasing software with -dirty anyways. Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%s" % pieces["short"] else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" rendered += "+g%s" % pieces["short"] return rendered def render_pep440_post_branch(pieces): """TAG[.postDISTANCE[.dev0]+gHEX[.dirty]] . The ".dev0" means not master branch. Exceptions: 1: no tags. 0.postDISTANCE[.dev0]+gHEX[.dirty] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["branch"] != "master": rendered += ".dev0" rendered += plus_or_dot(pieces) rendered += "g%s" % pieces["short"] if pieces["dirty"]: rendered += ".dirty" else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["branch"] != "master": rendered += ".dev0" rendered += "+g%s" % pieces["short"] if pieces["dirty"]: rendered += ".dirty" return rendered def render_pep440_old(pieces): """TAG[.postDISTANCE[.dev0]] . The ".dev0" means dirty. Exceptions: 1: no tags. 0.postDISTANCE[.dev0] """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"] or pieces["dirty"]: rendered += ".post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" else: # exception #1 rendered = "0.post%d" % pieces["distance"] if pieces["dirty"]: rendered += ".dev0" return rendered def render_git_describe(pieces): """TAG[-DISTANCE-gHEX][-dirty]. Like 'git describe --tags --dirty --always'. Exceptions: 1: no tags. HEX[-dirty] (note: no 'g' prefix) """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] if pieces["distance"]: rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render_git_describe_long(pieces): """TAG-DISTANCE-gHEX[-dirty]. Like 'git describe --tags --dirty --always -long'. The distance/hash is unconditional. Exceptions: 1: no tags. HEX[-dirty] (note: no 'g' prefix) """ if pieces["closest-tag"]: rendered = pieces["closest-tag"] rendered += "-%d-g%s" % (pieces["distance"], pieces["short"]) else: # exception #1 rendered = pieces["short"] if pieces["dirty"]: rendered += "-dirty" return rendered def render(pieces, style): """Render the given version pieces into the requested style.""" if pieces["error"]: return { "version": "unknown", "full-revisionid": pieces.get("long"), "dirty": None, "error": pieces["error"], "date": None, } if not style or style == "default": style = "pep440" # the default if style == "pep440": rendered = render_pep440(pieces) elif style == "pep440-branch": rendered = render_pep440_branch(pieces) elif style == "pep440-pre": rendered = render_pep440_pre(pieces) elif style == "pep440-post": rendered = render_pep440_post(pieces) elif style == "pep440-post-branch": rendered = render_pep440_post_branch(pieces) elif style == "pep440-old": rendered = render_pep440_old(pieces) elif style == "git-describe": rendered = render_git_describe(pieces) elif style == "git-describe-long": rendered = render_git_describe_long(pieces) else: raise ValueError("unknown style '%s'" % style) return { "version": rendered, "full-revisionid": pieces["long"], "dirty": pieces["dirty"], "error": None, "date": pieces.get("date"), } class VersioneerBadRootError(Exception): """The project root directory is unknown or missing key files.""" def get_versions(verbose=False): """Get the project version from whatever source is available. Returns dict with two keys: 'version' and 'full'. """ if "versioneer" in sys.modules: # see the discussion in cmdclass.py:get_cmdclass() del sys.modules["versioneer"] root = get_root() cfg = get_config_from_root(root) assert cfg.VCS is not None, "please set [versioneer]VCS= in setup.cfg" handlers = HANDLERS.get(cfg.VCS) assert handlers, "unrecognized VCS '%s'" % cfg.VCS verbose = verbose or cfg.verbose assert cfg.versionfile_source is not None, "please set versioneer.versionfile_source" assert cfg.tag_prefix is not None, "please set versioneer.tag_prefix" versionfile_abs = os.path.join(root, cfg.versionfile_source) # extract version from first of: _version.py, VCS command (e.g. 'git # describe'), parentdir. This is meant to work for developers using a # source checkout, for users of a tarball created by 'setup.py sdist', # and for users of a tarball/zipball created by 'git archive' or github's # download-from-tag feature or the equivalent in other VCSes. get_keywords_f = handlers.get("get_keywords") from_keywords_f = handlers.get("keywords") if get_keywords_f and from_keywords_f: try: keywords = get_keywords_f(versionfile_abs) ver = from_keywords_f(keywords, cfg.tag_prefix, verbose) if verbose: print("got version from expanded keyword %s" % ver) return ver except NotThisMethod: pass try: ver = versions_from_file(versionfile_abs) if verbose: print(f"got version from file {versionfile_abs} {ver}") return ver except NotThisMethod: pass from_vcs_f = handlers.get("pieces_from_vcs") if from_vcs_f: try: pieces = from_vcs_f(cfg.tag_prefix, root, verbose) ver = render(pieces, cfg.style) if verbose: print("got version from VCS %s" % ver) return ver except NotThisMethod: pass try: if cfg.parentdir_prefix: ver = versions_from_parentdir(cfg.parentdir_prefix, root, verbose) if verbose: print("got version from parentdir %s" % ver) return ver except NotThisMethod: pass if verbose: print("unable to compute version") return { "version": "0+unknown", "full-revisionid": None, "dirty": None, "error": "unable to compute version", "date": None, } def get_version(): """Get the short version string for this project.""" return get_versions()["version"] def get_cmdclass(cmdclass=None): """Get the custom setuptools/distutils subclasses used by Versioneer. If the package uses a different cmdclass (e.g. one from numpy), it should be provide as an argument. """ if "versioneer" in sys.modules: del sys.modules["versioneer"] # this fixes the "python setup.py develop" case (also 'install' and # 'easy_install .'), in which subdependencies of the main project are # built (using setup.py bdist_egg) in the same python process. Assume # a main project A and a dependency B, which use different versions # of Versioneer. A's setup.py imports A's Versioneer, leaving it in # sys.modules by the time B's setup.py is executed, causing B to run # with the wrong versioneer. Setuptools wraps the sub-dep builds in a # sandbox that restores sys.modules to it's pre-build state, so the # parent is protected against the child's "import versioneer". By # removing ourselves from sys.modules here, before the child build # happens, we protect the child from the parent's versioneer too. # Also see https://github.com/python-versioneer/python-versioneer/issues/52 cmds = {} if cmdclass is None else cmdclass.copy() # we add "version" to both distutils and setuptools from distutils.core import Command class cmd_version(Command): description = "report generated version string" user_options = [] boolean_options = [] def initialize_options(self): pass def finalize_options(self): pass def run(self): vers = get_versions(verbose=True) print("Version: %s" % vers["version"]) print(" full-revisionid: %s" % vers.get("full-revisionid")) print(" dirty: %s" % vers.get("dirty")) print(" date: %s" % vers.get("date")) if vers["error"]: print(" error: %s" % vers["error"]) cmds["version"] = cmd_version # we override "build_py" in both distutils and setuptools # # most invocation pathways end up running build_py: # distutils/build -> build_py # distutils/install -> distutils/build ->.. # setuptools/bdist_wheel -> distutils/install ->.. # setuptools/bdist_egg -> distutils/install_lib -> build_py # setuptools/install -> bdist_egg ->.. # setuptools/develop -> ? # pip install: # copies source tree to a tempdir before running egg_info/etc # if .git isn't copied too, 'git describe' will fail # then does setup.py bdist_wheel, or sometimes setup.py install # setup.py egg_info -> ? # we override different "build_py" commands for both environments if "build_py" in cmds: _build_py = cmds["build_py"] elif "setuptools" in sys.modules: from setuptools.command.build_py import build_py as _build_py else: from distutils.command.build_py import build_py as _build_py class cmd_build_py(_build_py): def run(self): root = get_root() cfg = get_config_from_root(root) versions = get_versions() _build_py.run(self) # now locate _version.py in the new build/ directory and replace # it with an updated value if cfg.versionfile_build: target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) cmds["build_py"] = cmd_build_py if "build_ext" in cmds: _build_ext = cmds["build_ext"] elif "setuptools" in sys.modules: from setuptools.command.build_ext import build_ext as _build_ext else: from distutils.command.build_ext import build_ext as _build_ext class cmd_build_ext(_build_ext): def run(self): root = get_root() cfg = get_config_from_root(root) versions = get_versions() _build_ext.run(self) if self.inplace: # build_ext --inplace will only build extensions in # build/lib<..> dir with no _version.py to write to. # As in place builds will already have a _version.py # in the module dir, we do not need to write one. return # now locate _version.py in the new build/ directory and replace # it with an updated value target_versionfile = os.path.join(self.build_lib, cfg.versionfile_build) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) cmds["build_ext"] = cmd_build_ext if "cx_Freeze" in sys.modules: # cx_freeze enabled? from cx_Freeze.dist import build_exe as _build_exe # nczeczulin reports that py2exe won't like the pep440-style string # as FILEVERSION, but it can be used for PRODUCTVERSION, e.g. # setup(console=[{ # "version": versioneer.get_version().split("+", 1)[0], # FILEVERSION # "product_version": versioneer.get_version(), # ... class cmd_build_exe(_build_exe): def run(self): root = get_root() cfg = get_config_from_root(root) versions = get_versions() target_versionfile = cfg.versionfile_source print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) _build_exe.run(self) os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] f.write( LONG % { "DOLLAR": "$", "STYLE": cfg.style, "TAG_PREFIX": cfg.tag_prefix, "PARENTDIR_PREFIX": cfg.parentdir_prefix, "VERSIONFILE_SOURCE": cfg.versionfile_source, } ) cmds["build_exe"] = cmd_build_exe del cmds["build_py"] if "py2exe" in sys.modules: # py2exe enabled? from py2exe.distutils_buildexe import py2exe as _py2exe class cmd_py2exe(_py2exe): def run(self): root = get_root() cfg = get_config_from_root(root) versions = get_versions() target_versionfile = cfg.versionfile_source print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, versions) _py2exe.run(self) os.unlink(target_versionfile) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] f.write( LONG % { "DOLLAR": "$", "STYLE": cfg.style, "TAG_PREFIX": cfg.tag_prefix, "PARENTDIR_PREFIX": cfg.parentdir_prefix, "VERSIONFILE_SOURCE": cfg.versionfile_source, } ) cmds["py2exe"] = cmd_py2exe # we override different "sdist" commands for both environments if "sdist" in cmds: _sdist = cmds["sdist"] elif "setuptools" in sys.modules: from setuptools.command.sdist import sdist as _sdist else: from distutils.command.sdist import sdist as _sdist class cmd_sdist(_sdist): def run(self): versions = get_versions() self._versioneer_generated_versions = versions # unless we update this, the command will keep using the old # version self.distribution.metadata.version = versions["version"] return _sdist.run(self) def make_release_tree(self, base_dir, files): root = get_root() cfg = get_config_from_root(root) _sdist.make_release_tree(self, base_dir, files) # now locate _version.py in the new base_dir directory # (remembering that it may be a hardlink) and replace it with an # updated value target_versionfile = os.path.join(base_dir, cfg.versionfile_source) print("UPDATING %s" % target_versionfile) write_to_version_file(target_versionfile, self._versioneer_generated_versions) cmds["sdist"] = cmd_sdist return cmds CONFIG_ERROR = """ setup.cfg is missing the necessary Versioneer configuration. You need a section like: [versioneer] VCS = git style = pep440 versionfile_source = src/myproject/_version.py versionfile_build = myproject/_version.py tag_prefix = parentdir_prefix = myproject- You will also need to edit your setup.py to use the results: import versioneer setup(version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), ...) Please read the docstring in ./versioneer.py for configuration instructions, edit setup.cfg, and re-run the installer or 'python versioneer.py setup'. """ SAMPLE_CONFIG = """ # See the docstring in versioneer.py for instructions. Note that you must # re-run 'versioneer.py setup' after changing this section, and commit the # resulting files. [versioneer] #VCS = git #style = pep440 #versionfile_source = #versionfile_build = #tag_prefix = #parentdir_prefix = """ OLD_SNIPPET = """ from ._version import get_versions __version__ = get_versions()['version'] del get_versions """ INIT_PY_SNIPPET = """ from . import {0} __version__ = {0}.get_versions()['version'] """ def do_setup(): """Do main VCS-independent setup function for installing Versioneer.""" root = get_root() try: cfg = get_config_from_root(root) except (OSError, configparser.NoSectionError, configparser.NoOptionError) as e: if isinstance(e, (OSError, configparser.NoSectionError)): print("Adding sample versioneer config to setup.cfg", file=sys.stderr) with open(os.path.join(root, "setup.cfg"), "a") as f: f.write(SAMPLE_CONFIG) print(CONFIG_ERROR, file=sys.stderr) return 1 print(" creating %s" % cfg.versionfile_source) with open(cfg.versionfile_source, "w") as f: LONG = LONG_VERSION_PY[cfg.VCS] f.write( LONG % { "DOLLAR": "$", "STYLE": cfg.style, "TAG_PREFIX": cfg.tag_prefix, "PARENTDIR_PREFIX": cfg.parentdir_prefix, "VERSIONFILE_SOURCE": cfg.versionfile_source, } ) ipy = os.path.join(os.path.dirname(cfg.versionfile_source), "__init__.py") if os.path.exists(ipy): try: with open(ipy) as f: old = f.read() except OSError: old = "" module = os.path.splitext(os.path.basename(cfg.versionfile_source))[0] snippet = INIT_PY_SNIPPET.format(module) if OLD_SNIPPET in old: print(" replacing boilerplate in %s" % ipy) with open(ipy, "w") as f: f.write(old.replace(OLD_SNIPPET, snippet)) elif snippet not in old: print(" appending to %s" % ipy) with open(ipy, "a") as f: f.write(snippet) else: print(" %s unmodified" % ipy) else: print(" %s doesn't exist, ok" % ipy) ipy = None # Make sure both the top-level "versioneer.py" and versionfile_source # (PKG/_version.py, used by runtime code) are in MANIFEST.in, so # they'll be copied into source distributions. Pip won't be able to # install the package without this. manifest_in = os.path.join(root, "MANIFEST.in") simple_includes = set() try: with open(manifest_in) as f: for line in f: if line.startswith("include "): for include in line.split()[1:]: simple_includes.add(include) except OSError: pass # That doesn't cover everything MANIFEST.in can do # (http://docs.python.org/2/distutils/sourcedist.html#commands), so # it might give some false negatives. Appending redundant 'include' # lines is safe, though. if "versioneer.py" not in simple_includes: print(" appending 'versioneer.py' to MANIFEST.in") with open(manifest_in, "a") as f: f.write("include versioneer.py\n") else: print(" 'versioneer.py' already in MANIFEST.in") if cfg.versionfile_source not in simple_includes: print(" appending versionfile_source ('%s') to MANIFEST.in" % cfg.versionfile_source) with open(manifest_in, "a") as f: f.write("include %s\n" % cfg.versionfile_source) else: print(" versionfile_source already in MANIFEST.in") # Make VCS-specific changes. For git, this means creating/changing # .gitattributes to mark _version.py for export-subst keyword # substitution. do_vcs_install(manifest_in, cfg.versionfile_source, ipy) return 0 def scan_setup_py(): """Validate the contents of setup.py against Versioneer's expectations.""" found = set() setters = False errors = 0 with open("setup.py") as f: for line in f.readlines(): if "import versioneer" in line: found.add("import") if "versioneer.get_cmdclass()" in line: found.add("cmdclass") if "versioneer.get_version()" in line: found.add("get_version") if "versioneer.VCS" in line: setters = True if "versioneer.versionfile_source" in line: setters = True if len(found) != 3: print("") print("Your setup.py appears to be missing some important items") print("(but I might be wrong). Please make sure it has something") print("roughly like the following:") print("") print(" import versioneer") print(" setup( version=versioneer.get_version(),") print(" cmdclass=versioneer.get_cmdclass(), ...)") print("") errors += 1 if setters: print("You should remove lines like 'versioneer.VCS = ' and") print("'versioneer.versionfile_source = ' . This configuration") print("now lives in setup.cfg, and should be removed from setup.py") print("") errors += 1 return errors if __name__ == "__main__": cmd = sys.argv[1] if cmd == "setup": errors = do_setup() errors += scan_setup_py() if errors: sys.exit(1)