Aug 12, 2026, version 10.5.0

    * GrB_Matrix_resize, GrB_Vector_resize: no longer call GrB_wait if the
        matrix/vector is sparse/hypersparse, and both dimensions are not
        decreasing.
    * GrB_Matrix_build and GrB_Vector_build: no longer do a post-iso check; they
        leave the matrix in non-iso format even if all the entries are the same.
    * (70) bug fix:  potential buffer overflow in eWiseUnion when using
        builtin 1st, 2nd, or positional operators

Aug 8, 2026, version 10.4.1

    * (69) bug fix for Windows: OpenMP for-loop on Windows.
        Caught by Erik Welch.

Aug 7, 2026, version 10.4.0

    * Memory arenas: allows the use of multiple memory allocators.
    * substantial revision to MATLAB/Octave interface: GhB is a new handle   
        object, so that m-files and mexFunctions can modify their inputs.  This
        allows pending work to be left in a GhB matrix, speeding up algorithms
        that use GraphBLAS.
    * GrB_Matrix_extractElement: no longer waits if the entry can be
        found without finalizing pending tuples
    * GxB_atfork_(prepare,parent,child): added to support an application
        needing to fork, while still using GraphBLAS.
    * static GrB_Matrix headers: used internally; removed, except for
        GB_Scalar_wrap, and unary/binary ops, to simplify memory arena feature
        and future CUDA kernels
    * MATLAB/Octave (68) bug fix:  v10.0 to v10.3 do not properly load GrB
        hypersparse matrices from *.mat files saved by v9 and earlier, when
        using the built-in load/save methods in MATLAB.  The load/save of a
        serialized blob is not affected by this bug.

July 21, 2026, version 10.3.2

    * compiler port: changes required for recent clang compilers
    * cmake: 3.23 now required; SuiteSparsePolicy.cmake revised.

Jan 21, 2026, version 10.3.1

    * (67) bug fix:  incorrect JIT kernel constructed for R=masker(C,M,Z)
        when R is hypersparse.  Found by Roi Lipman, FalkorDB.
    * (66) bug fix:  GB_bitonic did not compile with the MS cl compiler.
        Found by Erik Welch, NVIDIA.

Dec 3, 2025, version 10.3.0

    * GrB_extract: performance improvement for C=A(I,J) when A is very large
        and (typically) hypersparse, and I is an explicit list and also large.
    * GrB_(Matrix,Vector,Scalar)_dup:  pending work is now left unfinished;
        any pending work in the input matrix will appear in the copy.  In
        v10.2.0 and earlier, all pending work in the input matrix was finished
        first.  To obtain the behavior in v10.2.0 and earlier, simply call
        GrB_*_wait on the input matrix before calling GrB_*_dup.

Nov 1, 2025, version 10.2.0

    * printing of user-defined types: get/set with GxB_PRINT_FUNCTION
    * doc: documentation of GrB_Matrix_import/export was backwards
    * performance: new GrB_assign kernel for C<C,struct> += A added

July 25, 2025: version 10.1.1

    * gcc can now be used the Power or s390:  workaround added;
        see Source/mxm/factory/GB_AxB_saxpy3_symbolic_fine_template.c.
	This resolves the issue found in v10.1.0.
    * OpenMP usage: replace omp critical with lock/unlock.
    * MATLAB: added method for getting/setting the JIT cache path.
    * JIT file lock/unlock: removed; if multiple user processes use
        GraphBLAS at the same time, each must set their own unique JIT cache.
    * (65) bug fix: theta type definitions for user-defined index binary ops
        were incorrectly typedef'd in the JIT kernels.

June 1, 2025: version 10.1.0

    * add support for RISC-V vectorization: contributed by Rodion Suvorov
    * added GRAPHBLAS_VANILLA: compile-time flag that disables all GxB methods
    * gcc and the Power or s390 processor:  using gcc on the Power or s390
        architecture leads to a failure in the OpenMP atomic capture intrinsic.
        See Source/mxm/factory/GB_AxB_saxpy3_symbolic_template.c.  The cmake
        build system has been revised so that it refuses to use gcc on a
        Power-based or s390-based system.  Use clang or the IBM xlc compiler
        instead.
    * GxB_STDC_VERSION: this is normally equal to __STDC_VERSION__ and is
        determined automatically in GraphBLAS.h.  If it is >= 2011012L,
        then C11 is being used and the polymorphic functions (based on
        _Generic) are available.  It can now be #define'd by the user
        application prior to its '#include "GraphBLAS.h"' statement.
        If a C++ compiler is used to compile the user application then
        GxB_STDC_VERSION is set to 199001L to denote C90 (and no _Generic
        keyword is used).  See GraphBLAS/Demo/Include/graphblas_demo.h
        for an example usage.
    * minor updates to build system
    * iterator methods: revised so they do not conflict with the copy of
        GraphBLAS v7.4.4 used inside MATLAB R2024b.  No effect on normal
        C API, so no change in major SO number for this release.

May 5, 2025: version 10.0.5

    * revised cmake build system
    * (64) bug fix: GrB_assign, C<M>+=A, method 08n, when A is full.
        Caught by Gabe Gomez.
    * (63) bug fix: GrB_mxm when using the masked dot-product
        and the output matrix is iso-valued.

Apr 10, 2025: version 10.0.3

    * upgrade xxHash to 0.8.3: contributed by Christoph Grueninger
    * upgrade cpu_features to 0.9.0: contributed by Christoph Grueninger
    * Octave interface: revised for the recent MacOS (15.3.2), assuming that
        both octave and OpenMP are installed via homebrew.
    * (62) bug fix: GxB_Matrix_build*Vector when C is held by row and
        I,J have different integer types; was broken.

Mar 20, 2025: version 10.0.2

    * performance:  improved the performance of GrB_setElement when many
        entries are inserted into a matrix that is initially empty.
    * (61) bug fix: GxB_Serialized_get_Scalar declared twice in GraphBLAS.h;
        caught by Erik Welch.

Mar 6, 2025: version 10.0.1

    * (60) bug fix: one of the GrB_mxm kernels (saxpy4) can hit a segfault for
        user-defined types, in the JIT kernels.  Caught by Gabe Gomez.

Mar 1, 2025: version 10.0.0

    * 32/64 bit matrices and vectors: the GrB_Matrix and GrB_Vector
        now exploit 32-bit integers when possible.  New methods added to pass
        32-bit integer arrays to/from GrB_build, extract, assign, subassign,
        and extractTuples.  New object, the GxB_Container added for fast
        import/export of matrices/vectors with arbitrary integer content.
    * GrB_Field: this enum is strongly deprecated, and replaced with
        'typedef int GrB_Field'.  This is an upward-compatible change to the
        API, and will allow the creation of a future mathematical field object
        in GraphBLAS.  This type should not be used; use an int instead.
        It will be removed or replaced in a future version of GraphBLAS.
    * enum parameters: replaced all enum parameters with int, to simplify
        future updates to enum parameters, including the GrB_Field.
    * GxB_JIT_ERROR: added in 9.4.x, changed value to avoid conflict with
        LAGraph error codes.
    * pack/unpack: these are declared historical; they still work but use
        64-bit integers only.  Use the new GxB_Container methods instead.
    * GxB_Matrix_iso and GxB_Vector_iso: declared historical; use GrB_get
        with the new GxB_ISO enum.
    * GxB_Matrix_type, GxB_Vector_type, GxB_Scalar_type: no longer historical;
        added back to the user guide.
    * Summary: the API is upward-compatible with 9.4.x, but only after
        the user application is recompiled with GraphBLAS v10.0.0.
        As a result, the SO version must increase from 9 to 10.

Feb 20, 2025: version 9.4.5

    * (59) bug fix: the GxB_NO_INT32 and GxB_NOT_INT64 flags in GB_control.h
        did not completely remove some of the INT32 and INT64 factory kernels.
        Caught by Erik Welch, NVIDIA.
    * AppleClang compiler bug:  On the Mac, the Source/mask/GB_masker.c file
        triggers a bug in AppleClang 16.0.0 with -O3 in (MacOS 14.6.1 (23G93),
        Xcode 16.2, Apple clang version 16.0.0, clang-1600.0.26.6).  It also
        fails in MacOS 15.2 (Target: arm64-apple-darwin23.6.0).  The bug is
        triggered by these tests in LAGraph (v1.2 branch, unreleased, Jan 4,
        2025):
	 39 - LAGraphX_BF (SIGTRAP)
	 40 - LAGraphX_Coarsen_Matching (Failed)
	 41 - LAGraphX_FastGraphletTransform (SIGTRAP)
	 49 - LAGraphX_PageRankGX (SIGTRAP)
	 54 - LAGraphX_SquareClustering (SIGTRAP)
	 61 - LAGraphX_msf (Failed)
        When using clang, optimization is turned off for this file.  This has
        no impact on performance since GB_masker.c is very simple, consisting
        of a single sequence of calls to other methods.

Feb 17, 2025: version 9.4.4

    * (58) bug fix: semirings with user-defined monoids and the GrB_ONEB or
        GxB_PAIR operators caused a JIT compiler error.  Caught by Gabe Gomez.
    * (57) bug fix: GraphBLAS.h header: remove duplicate definitions of
        GxB_MAX_FIRST_* semirings (incompletely moved to 'historical' section
        in 9.4.2).

Nov 18, 2024: version 9.4.2

    * clarified User Guide: regarding when the hyper-hash is built
    * JIT: reduced JIT kernel encodings
    * also: includes the updates from 9.4.0.beta and 9.4.1.beta listed below

Nov 15, 2024: version 9.4.1 (only released as BETA)

    * new JIT kernels added: for GrB_assign, GrB_extract, GxB_sort,
        GrB_kronecker, stand-alone mask phase, and utilities (convert to/from
        sparse/bitmap, unjumble).  All kernels formerly tagged "JIT: needed"
        are now finished.
    * removed Factory kernels for: types int8 and uint8, and semirings:
        max_min, max_plus, max_times, min_max, min_times, plus_min, plus_max,
        non-Boolean land/lor/lxor/lxnor, and integer times_first/second,
        to reduce size of compiled library.  JIT kernels will be used instead
        for these types and semirings.
    * GxB_IndexBinaryOp: finalized and named as GxB_*.

Oct 15, 2024: version 9.4.0 (only released as BETA)

    * new operator and associated methods: added the draft G*B_IndexBinaryOp
    * JIT error-handling behavior changed:  if a compiler error occurs in the
        JIT, GxB_JIT_ERROR is now returned.  Previously, GraphBLAS would fall
        back to a generic method if such an error occurred.

Aug 12, 2024: version 9.3.1

    * (56) bug fix:  wrong type for fgetc return value in JITpackage; leads
        to infinite loop on some systems when building GraphBLAS.

Aug 2, 2024: version 9.3.0

    * code restructuring:  Source folder split into many subfolders, and
        some files and internal functions renamed.  No visible external change.
    * (55) bug fix: GrB_apply with user-defined index-unary op would fail if
        A was iso and the JIT was disabled (failure in generic case).
        Caught by Christina Koutsou.
    * (54) bug fix: reducing a huge iso full matrix to a scalar resulted in
        integer overflow if nrows*ncols was larger than about 2^60.
    * reduced size of compiled library: int16 and uint16 types and operators
        for FactoryKernels are disabled in GB_control.h.  The JIT will always
        be used instead.

May 22, 2024: version 9.2.0

    * Added graphblas_install.m: for a simpler method of compiling
        the MATLAB/Octave interface for GraphBLAS.
    * JIT: sanitizing the JIT cache path, better burble for compiler errors
    * GrB_get/GrB_set: better handling of concurrent get/set between different
        user threads

Mar 22, 2024: version 9.1.0

    * minor updates to build system
    * C11 complex type detection:  this is now detected and configured by
        cmake, instead of using an #if ... in the GraphBLAS.h header.
        This change was required to port GraphBLAS to the clang-cl compiler
        on Windows when it simulates the MSVC compiler.  Also added a new
        feature (thus the minor version update to 9.1.0): GxB_HAVE_COMPLEX* to
        GraphBLAS.h to indicate which kind of complex data types are available
        in C11 or MSVC.  Contributed by Markus Mützel.
    * port to clang-cl: fixing the GxB_get and GxB_set macro
    * (53) bug fix: eWiseAdd C<M>=A+B when M, A, and B are all hypersparse;
        access to M was incorrect (also affects C<M>+=T for any operation, if
        M and T are both hypersparse).  Caught by Roi Lipman.

Mar 1, 2024: version 9.0.3

    * (52) performance bug fix: JIT kernels since v8.3.1 were not compiled with
        OpenMP.

Feb 26, 2024: version 9.0.2

    * (51) bug fix: GraphBLAS/Makefile "make static" was incorrect.

Jan 20, 2024: version 9.0.1

    * minor updates to build system

Jan 10, 2024: version 9.0.0

    * GrB_get/GrB_set: new functions from the v2.1 C API.
    * GrB_Type_new, GrB_UnaryOp_new, GrB_IndexUnaryOp_new: no longer macros,
        since GrB_set can be used to set the names of the operators.  These
        methods no longer extract the name, so the default name is now the
        empty string.  This is because GrB_get/set can only set these names
        once.  This is a non-compatible change of behavior for these 3
        methods, so SuiteSparse:GraphBLAS must become v9.0.0.
    * historical methods:  many methods are replaced by GrB_get and GrB_set.
        They remain in SuiteSparse:GraphBLAS but have been declared historical.
        Terse prototypes exist in GraphBLAS.h, and any discussion is removed
        from the User Guide:  GxB_get, GxB_set, and the methods they call, and
        many more.  Use GrB_get/set in place those methods, and for:
        GxB_*type_name, GxB_*type, GxB_Monoid_operator, GxB_Monoid_identity,
        GxB_Monoid_terminal, GxB_Semiring_add, GxB_Semiring_multiply.  Use
        GrB_STORAGE_ORIENTATION_HINT in place of GxB_FORMAT.
    * hyper_hash: constructed only if the # of non-empty vectors in a
        hypersparse matrix is large (> 1024, by default)
    * minor updates to build system: *.pc files for pkgconfig

Dec 30, 2023: version 8.3.1

    * major change to build system: by Markus Mützel
    * GraphBLAS.h: remove "undef I"

Oct 7, 2023: version 8.2.1

    * (50) bug fix: remove undefined behavior in Source/GB_add.c with
        Cnvec_nonempty, caught by Yves Vandreissche, Intel
    * (49) bug fix: GrB_mxm saxpy4 and saxpy5 had incorrectly handling of
        typecasting in v8.0.0 to v8.2.0 (caught by Erik Welch)
    * cross-compiler support: replace check_c_source_runs with _compiles,
        for GraphBLAS and SuiteSparse_config, and remove check for
        getenv("HOME").
    * cmake update: add "None" build type, from Antonio Rojas, for Arch Linux

Sept 8, 2023: version 8.2.0

    * cmake updates: SuiteSparse:: namespace by Markus Muetzel
    * GB_VLA_MAXSIZE: increased to 1024; only affects compilers not
        supporting variable-length arrays (MSVC)

Version 8.0.2, June 16, 2023

    * added -DJITINIT=option:  use -DJITINIT to set the initial state of
        the GxB_JIT_CONTROL (4:on, 3:load, 2:run, 1:pause, 0:off).  The default
        is 4 (on) if the JIT is enabled, or 2 (run) if -DNJIT=1 is set.
    * xxHash: upgraded to latest version as of June 16, 2023

Version 8.0.1, May 27, 2023

    * (48) bug fix: GrB_*_nvals returned UINT64_MAX ('infinity') for a
        GrB_Vector of size n-by-2^60; it should return 2^60.
        Caught by Erik Welch, NVIDIA.
    * added GxB_Context_error and GxB_Context_wait
    * C++: changed complex typedefs for C++ that #include GraphBLAS.h;
        update from Markus Muetzel

Version 8.0.0, May 18, 2023

    * version 8:  This version is a major SO version increase, since
        it removes a few minor user-visible features from SuiteSparse:GraphBLAS:
        the GrB_Descriptor no longer supports threading control, and some
        features of the GxB_SelectOp are removed (see below).  Enum values have
        been changed for compatibility with the upcoming GrB_set/get features
        in the V2.1 C API.
    * The JIT:  GraphBLAS v8.0.0 now includes a JIT for the CPU kernels, which
        can compile kernels at run time.  Added GxB_set/get options and
        environment variables to control the JIT.  The GxB_*Op_new methods can
        accept NULL function pointers, if the strings are provided and valid.
    * GxB_Type_new: the size of the type can be given as zero,
        in which case the size is determined via a JIT kernel.
    * GxB_UnaryOp_new, GxB_BinaryOp_new, and GxB_IndexUnaryOp_new: the function
        pointer can be given as NULL, in which case the function is created by
        the JIT.
    * math kernels: revised for CUDA JIT.  More accurate complex
        floating-point for Mac OS on Apple Silicon.
    * Demo/wildtype_demo: change to double so that CPU and GPU versions compute
        the same result.
    * GxB_get: can return malloc/calloc/realloc/free functions
    * GxB_Context: an object for controlling computational resources:
        # of OpenMP threads, the chunk factor, and (draft) GPU id.
    * GrB_Descriptor: removed ability to control # of OpenMP threads from the
        descriptor (a rarely used feature).  Replaced with the GxB_Context
        object.
    * GxB_SelectOp: GraphBLAS no longer supports user-defined GxB_SelectOps.
        Use a GrB_IndexUnaryOp instead.  The GxB_SelectOp_new and
        GxB_SelectOp_free functions are removed entirely.  The built-in
        GxB_SelectOps, GxB_Matrix_select, GxB_Vector_select, and GxB_select
        still work.  However, the GxB_EQ_THUNK, GxB_EQ_ZERO, GxB_NE_THUNK, and
        GxB_NE_ZERO operators no longer work on user-defined types, as they did
        in v7.4.4 and earlier.  Create a user-defined GrB_IndexUnaryOp to
        compute these operations instead, and use GrB_select.
    * alternative/Makefile: removed; incompatible with the JIT
    * zstd: upgraded to v1.5.5 (Apr 4, 2023)

Version 7.4.4, Mar 25, 2023

    * (47) bug fix: OpenMP atomics require seq_cst on the ARM.
        Revised GB_atomics.h accordingly, and added them for all
        architectures (caught by Gabor Szarnyas).

Version 7.4.3, Jan 20, 2023

    * debug: turned on in GrB_Matrix_removeElement by mistake.

Version 7.4.2, Jan 17, 2023

    * minor change to build system: for SuiteSparse v7.0.0
    * deprecation notice:  in GraphBLAS v8.0.0, the ability to set the
        # of threads, and chunk size, in the descriptor will be removed.
        It still appears in v7.x, but will be replaced by a Context object
        in v8.0.0.

Version 7.4.1, Jan 9, 2023

    * global free pool: disabled.  Benefit for single-thread user applications
        was modest, and it causes too much contention in a critical section
        when the user application is multi-threaded.
    * GrB_mxm: revised task creation heuristics for sparse-times-sparse for
        better performance.  "chunk" and "very_costly" had been tuned in v7.3.x
        for sparse-times-dense but this slowed down sparse-times-sparse.  The
        new heuristic keeps the chunk & very_costly parameters for
        sparse-times-dense but restores the prior values for
        sparse-times-sparse from v7.2.0 (Aug 8, 2022).  See
        Source/GB_AxB_saxpy3_slice_balanced.c.

Version 7.4.0, Dec 23, 2022

    * added non-va_arg methods: va_arg-based GxB_get/set methods are C11
        but cause issues for cffi in Python.  As a temporary workaround, new
        methods have been added that do not use va_arg.  The existing
        GxB_get/set methods are not changed.  The new methods are not in the
        user guide, since all of the GxB_get/set methods will be superceded
        with GrB_get/set in the v2.1 C API.  At that point, all GxB_get/set
        methods will become historical (kept, not deprecated, but removed from
        the user guide).

Version 7.3.3, Dec 9, 2022

    * minor change to build system
    * stdatomic.h: using #include <stdatomic.h> and atomic_compare_exchange_weak
        instead of GCC/clang/icx __atomic_* variants.
        Added -latomic if required.
    * chunk factor for C=A*B (saxpy3 method): revised for non-builtin-semirings

Version 7.3.2, Nov 12, 2022

    * cmake_modules: minor revision to build system, to sync
        with SuiteSparse v6.0.0
    * Added option -DNOPENMP=1 to disable OpenMP parallelism

Version 7.3.1, Oct 21, 2022

    * workaround for Microsoft Visual Studio bug :  MSC 19.2x (in vs2019)
        encounters a compiler bug when compiling the FIRST_FC32 and SECOND_FC32
        binary operators.  This version adds a flag that disables those
        methods.  The operators still work, they are just handled by the
        slower generic methods. Thanks to Erik Welch, H. Vetinari, and others
        in the conda-forge community for tracking this down.

Version 7.3.0, Oct 14, 2022

    * GrB_Matrix: changes to the internal data structure
        * minor internal changes: A->nvals for sparse/hypersparse
        * more significant changes: added A->Y hyper_hash for hypersparse case,
            speeds up GrB_mxm (C=A*B, C<M>=A*B' (for CSR A'*B for CSC)),
            C<M>=A+B (eWiseAdd), C<M>A.*B (eWiseMult), some cases for
            GrB_assign, for hypersparse matrices.
        * added GxB_unpack_HyperHash and GxB_pack_HyperHash: to pack/unpack
            the A->Y hyper_hash
    * GrB MATLAB/Octave interface: changed license to Apache-2.0
    * MATLAB library: renamed to libgraphblas_matlab.so
    * performance: faster C=A*B when using a single thread and B is a
        sparse vector with many entries

Version 7.2.0, Aug 8, 2022

    * added ZSTD as a compression option for serialize/deserialize:
        Version 1.5.3 by Yann Collet, https://github.com/facebook/zstd.git
        Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
        Included in SuiteSparse:GraphBLAS via its BSD-3-clause license.
        The default method is now ZSTD, level 1.
    * added GxB_Matrix_reshape and GxB_Matrix_reshapeDup
    * MATLAB interface: faster C(:)=A, C=A(:), and reshape.
        Better error messages.

Version 7.1.2, July 8, 2022

    * MATLAB interface: linear indexing added for C(:)=A, C=A(:), and
        single-output I=find(C).  Faster bandwidth, istriu, istril,
        isbanded, isdiag.  C(I,J)=A can now grow the size of C.

Version 7.1.1, June 17, 2022

    * minor updates to documentation and error messages
    * MATLAB interface: minor revision of GrB.deserialize

Version 7.1.0, May 20, 2022

    * added cube root: GxB_CBRT_FP* unary operators
    * added GxB_Matrix_isStoredElement and GxB_Vector_isStoredElement

Version 7.0.4, Apr 25, 2022

    * (46) bug fix: user-defined type size was incorrectly limited
        to 128 bytes.  Caught by Erik Welch.

Version 7.0.3, Apr 8, 2022

    * faster transpose when using 2 threads

Version 7.0.2, Apr 6, 2022

    * (45) bug fix: vector iterator was broken for iterating across a
        vector in bitmap format.  Caught by Erik Welch.

Version 7.0.1, Apr 3, 2022

    * revised ACM TOMS submission: Doc/toms_parallel_grb2.pdf

Version 7.0.0, Apr 2, 2022

    * (44) spec bug: GrB_Matrix_diag was implemented in v5.2.x and v6.x with
        the wrong signature.  This fix requires the major release to change,
        from v6.x to v7.x, since the change means that the revised v7 is not
        backward compatible with v6.
    * performance for GrB_mxm: auto selection for saxpy method (Hash vs
        Gustavson) revised.
    * (43) performance bug fix for GrB_assign: better performance for
        C(i,j)=scalar and C(i,j)+=scalar when i and j have length 1 (scalar
        assigment with no scalar expansion).  The prior code worked but this is
        a performance bug introduced in the parallel GraphBLAS.  The bug likely
        doesn't appear in v2.x (the sequential version of SS:GrB).  This
        affects method 1 of Demo/Source/wathen.c.  Caught by a reviewer of the
        ACM TOMS paper on the parallel GraphBLAS.

Version 6.2.5, Mar 14, 2022

    * For SuiteSparse v5.11.0

Version 6.2.4, Mar 8, 2022

    * (42) bug fix: GrB_mxm with 0-by-0 iso full matrices: Caught by
        Henry Amuasi in the Python grblas interface, then triaged and
        isolated by Erik Welch.

Version 6.2.3, Mar 5, 2022

    * minor update to documentation in GrB.build: no change to any code

Version 6.2.2 Feb 28, 2022

    * revised output of GxB_*_sort: to return newly created matrices
        C and P as full or bitmap matrices, as appropriate, instead of
        sparse/hypersparse, following their sparsity control settings

Version 6.2.1 Feb 16, 2022

    * (41) bug fix: GxB_Iterator_get used (void *) + siz arithmetic

Version 6.2.0 Feb 14, 2022

    * added row/column/entry/vector iterators
    * GrB C=A*B: revised sparse-times-full rule
    * static header: no longer used if CUDA enabled
    * GB_BURBLE: removed.  Burble can no longer be disabled at compile-time.

Version 6.1.4, Jan 13, 2022

    * added section to User Guide: how to get the best performance out of
        algorithms based on GraphBLAS
    * cpu_features:  no longer built as a separate library, but built directly
        into libgraphblas.so and libgraphblas.a.  Added compile-time flags to
        optionally disable the use of cpu_features completely.
    * Octave 7: port to Apple Silicon (thanks to Gabor Szarnyas)
    * min/max monoids:  real case (FP32 and FP64) no longer terminal
    * GrB interface: overloaded C=A*B syntax where one matrix is full always
        results in a full matrix C, which is faster and matches the Octave/
        MATLAB policy.

Version 6.1.3, Jan 1, 2022

    * performance: task creation for GrB_mxm (saxpy method) didn't
        account for any work for A(:,k)*B(k,j) when nnz(A(:,k))==0,
        but this takes O(1) work to examine B(k,j).  Performance
        improvement of up to 10x when nnz(A)<<nnz(B).

Version 6.1.2, Dec 31, 2021

    * performance: revised swap_rule in GrB_mxm, which decides whether
        to compute C=A*B or C=(B'*A')', and variants, resulting in up
        to 3x performance gain over v6.1.1 for GrB_mxm (observed;
        could be higher in other cases).

Version 6.1.1, Dec 28, 2021

    * minor revision to AVX2 and AVX512f selection
    * cpu_features/Makefile: remove test of list_cpu_features

Version 6.1.0, Dec 26, 2021

    * added GxB_get options: compiler name and version
    * added package: https://github.com/google/cpu_features,
        Nov 30, 2021 version
    * performance: faster C+=A*B when C is full, A is bitmap/full, and B is
        sparse/hyper; added saxpy5 kernel.  faster C+=A'*B (dot4 kernel).
    * (40) bug fix: deserialization of iso and empty matrices/vectors was broken

Versions 6.0.2 and 5.2.2, Nov 30, 2021

    * (39) bug fix: GrB_Matrix_export; numerical values not properly exported

Versions 6.0.1 and 5.2.1, Nov 27, 2021

    * v6.x and v5.x: differ only in GrB_wait, GrB_Info, GrB_SCMP, and GxB_init
    * (38) bug fix:  C+=A'*B when the accum operator is the same as the monoid
        and C is iso-full, and A or B are hypersparse (dot4 method).
    * performance: GrB_select with user-defined GrB_IndexUnaryOp ~2x faster.
    * performance: faster (MIN,MAX)_(FIRSTJ,SECONDI) semirings

Version 6.0.0, Nov 15, 2021

    * v6.0.0: this release contains only a few changes that cause a
        break with backward compatibility.  It is otherwise identical to v5.2.0.
    * Fully compliant with the v2.0 C API Specification: three changes from the
        v2.0 C API Spec are not backward compatible: (GrB_*wait, GrB_Info
        enum, and GrB_SCMP).  GxB_init has also changed.
        * GrB_wait (object, mode): was GrB_wait (&object).
        * GrB_Info: changed enum values
        * GrB_SCMP: removed
        * GxB_init (mode, malloc, calloc, realloc, free, is_thread_safe): the
            last parameter, is_thread_safe, is deleted.
            The malloc/calloc/realloc/free functions must be thread-safe.

Version 5.2.0, Nov 15, 2021

    * Added for the v2.0 C API Specification: only features that are
        backward compatible with SuiteSparse:GraphBLAS v5.x have been
        added to v5.2.0.
        * GrB_Scalar: replaces GxB_Scalar, GxB_Scalar_* functions renamed GrB
        * GrB_IndexUnaryOp: new, free, fprint, wait
        * GrB_select: selection via GrB_IndexUnaryOp
        * GrB_apply: with GrB_IndexUnaryOp
        * GrB_reduce: reduce matrix or vector to GrB_Scalar
        * GrB_assign, GrB_subassion: with GrB_Scalar input
        * GrB_*_extractElement_Scalar: get GrB_Scalar from a matrix or vector
        * GrB*build: when dup is NULL, duplicates result in an error.
        * GrB import/export: import/export from/to user-provided arrays
        * GrB_EMPTY_OBJECT, GrB_NOT_IMPLEMENTED: error codes added
        * GrB_*_setElement_Scalar: set an entry in a matrix or vector,
            from a GrB_Scalar
        * GrB_Matrix_diag: same as GxB_Matrix_diag (C, v, k, NULL)
        * GrB_*_serialize/deserialize: with compression
        * GrB_ONEB_T: binary operator, f(x,y)=1, the same as GxB_PAIR_T
    * GxB*import* and GxB*export*: now historical; use GxB*pack/unpack*
    * GxB_select: is now historical; use GrB_select instead.
    * GxB_IGNORE_DUP: special operator for build methods only; if dup
        is this operator, then duplicates are ignored (not an error)
    * GxB_IndexUnaryOp_new: create a named index-unary operator
    * GxB_BinaryOp_new: create a named binary operator
    * GxB_UnaryOp_new: create a named unary operator
    * GxB_Type_new: to create a named type
    * GxB_Type_name: to query the name of a type
    * added GxB_BinaryOp_xtype_name, GxB_BinaryOp_ytype_name,
        GxB_BinaryOp_ztype_name, GxB_deserialize_type_name,
        GxB_Matrix_type_name, GxB_Scalar_type_name, GxB_UnaryOp_xtype_name,
        GxB_UnaryOp_ztype_name, GxB_IndexUnaryOp_xtype_name,
        GxB_IndexUnaryOp_ytype_name, GxB_IndexUnaryOp_ztype_name,
        GxB_Vector_type_name: to query the name of a type as a string
    * GxB_BinaryOp_xtype, GxB_BinaryOp_ytype, GxB_BinaryOp_ztype,
        GxB_Matrix_type, GxB_Scalar_type, GxB_SelectOp_ttype,
        GxB_SelectOp_xtype, GxB_UnaryOp_xtype, GxB_UnaryOp_ztype,
        GxB_Vector_type: declared historical; use *type_name methods.
    * GxB_*_serialize/deserialize: with compression; optional descriptor
    * GxB_Matrix_sort, GxB_Vector_sort: sort a matrix or vector
    * GxB_eWiseUnion: like GrB_eWiseAdd except for how entries in A\B
        and B/A are computed.
    * added LZ4/LZ4HC: compression library, http://www.lz4.org (BSD 2),
        v1.9.3, Copyright (c) 2011-2016, Yann Collet, All Rights Reserved.
    * mis and pagerank demos: removed; mis added to LAGraph/experimental
    * disabled free memory pool if OpenMP not available
    * (37) bug fix: ewise C=A+B when all matrices are full, GBCOMPACT
        not used, but GB_control.h disabled the operator or type.
        Caught by Roi Lipman, Redis.
    * (36) bug fix: C<M>=Z not returning C as iso if Z iso and C initialy
        empty.  Caught by Erik Welch, Anaconda.
    * performance improvements: C=A*B: sparse/hyper times bitmap/full,
        and visa versa, including C += A*B when C is full

Version 5.1.10, Oct 27, 2021

    * (35) bug fix: GB_selector; A->plen and C->plen not updated correctly.
        Caught by Jeffry Lovitz, Redis.

Version 5.1.9, Oct 26, 2021

    * (34) bug fix: in-place test incorrect for C+=A'*B using dot4
    * (33) bug fix: disable free pool if OpenMP not available

Version 5.1.8, Oct 5, 2021

    * (32) bug fix: C=A*B when A is sparse and B is iso and bitmap.
        Caught by Mark Blanco, CMU.

Version 5.1.7, Aug 23, 2021

    * (31) bug fix:  GrB_apply, when done in-place and matrix starts
        non-iso and becomes iso, gave the wrong iso result.
        Caught by Fabian Murariu.

Version 5.1.6, Aug 16, 2021

    * one-line change to C=A*B: faster symbolic analysis when a vector
        C(:,j) is dense (for CSC) or C(i,:) for CSR.
    * port to MacOSx 11.3.1 (Big Sur): cmake 3.13 or later now required.

Version 5.1.5, July 15, 2021

    * ACM TOMS submission: rename some functions to simplify discussion
        in ACM TOMS article

Version 5.1.4, July 6, 2021

    * faster Octave interface, and a bug fix for 1-based printing
    * (30) bug fix: 1-based printing not enabled for pending tuples.
        Caught by Will Kimmerer.

Version 5.1.3, July 3, 2021

    * added GxB_Matrix_iso and GxB_Vector_iso: to query if a matrix or vector
        is held as iso-valued.
    * (29) bug fix: Matrix_pack_*R into a matrix previously held by
        column, or pack*C into a matrix by row, would flip the dimensions.
        Caught by Erik Welch, Anaconda.

Version 5.1.2, June 30, 2021

    * (28) bug fix: kron(A,B) with iso input matrices A and B fixed.
        Caught by Michel Pelletier, Graphegon.

Version 5.1.1, June 29, 2021

    * (27) bug fix: v5.1.0 had a wrong version of a file (GB_ops.c,
        which wouldn't compile) posted by mistake.
        Caught by Michel Pelletier, Graphegon.

Version 5.1.0, June 28, 2021

    * iso matrices and vectors added
    * GxB_*_build_Scalar added: builds an iso matrix or vector
    * import/export: can now import/export iso matrices and vectors
    * GxB_*_pack/unpack methods added
    * GrB.argmin/argmax: added to GrB interface
    * GxB_PRINT_1BASED: added to the global settings
    * GxB_Matrix_memoryUsage and related methods: added
    * Source/Generated: split into Source/Generated1 and Source/Generated2
        for faster compilation when GBCOMPACT is enabled
    * port to Octave:  gbmake and gbtest work in Octave7 to build and test
        the GrB interface to GraphBLAS.  Octave 7.0.0 is required.

Version 5.0.6, May 24, 2021

    * bfs and triangle counting demos: removed.  See LAGraph for these
        algorithms.

Version 5.0.5, May 17, 2021

    * (26) performance bug fix:  reduce-to-vector where A is hypersparse CSR
        with a transposed descriptor (or CSC with no transpose), and some cases
        for GrB_mxm/mxv/vxm when computing C=A*B with A hypersparse CSC and B
        bitmap/full (or A bitmap/full and B hypersparse CSR), the wrong
        internal method was being selected via the auto-selection strategy,
        resulting in a significant slowdown in some cases.

Version 5.0.4, May 13, 2021

    * GrB interface: changed license from Apache-2.0
        to GNU GPLv3 or later.

Version 5.0.3, May 12, 2021

    * (25) bug fix: disabling ANY_PAIR semirings in Source/GB_control.h would
        cause a segfault if those disabled semirings were used.
    * demos: no longer built by default
    * (24) bug fix: GB_PUBLIC added to the new functions in GraphBLAS.h
    * GrB_Matrix_reduce_BinaryOp: reinstated from v4.0.3;
        same limit on built-in ops that correspond to known monoids.
    * Source/GB_control.h: more semirings disabled by default to reduce
        compile time and binary library size.  The semirings still work, but
        are not as fast since they now use the generic methods.

Version 5.0.2, May 5, 2021

    * GrB_Matrix_reduce_BinaryOp: removed.  Use a monoid instead, with
        GrB_reduce or GrB_Matrix_reduce_Monoid.
    * (23) bug fix: GrB_Matrix_apply_BinaryOp1st and 2nd were using the
        wrong descriptors for GrB_INP0 and GrB_INP1. Caught by Erik Welch,
        Anaconda.
    * memory pool added for faster memory allocation
    * calloc no longer used: using malloc+memset(0) instead
    * realloc option: if not available, uses malloc+memcpy+free
    * GrB interface ported to R2021a.
    * GxB_Matrix_diag: construct a diagonal matrix from a vector
    * GxB_Vector_diag: extract a diagonal from a matrix
    * concat/split: added methods to concatenate and split matrices
    * import/export: size of arrays now in bytes, not entries.
        A new parameter, is_uniform, has been added to all import/export
        methods, which indicates that the matrix values are all the same.
    * (22) bug fix: SIMD vectorization was missing reduction(+,task_cnvals)
        in GB_dense_subassign_06d_template.c.  Caught by Jeff Huang, Texas A&M,
        with his software package for race-condition detection.

Version 4.0.3, Jan 19, 2021

    * faster min/max monoids
    * GrB: G=GrB(G) converts G from v3 object to v4

Version 4.0.2, Jan 11, 2021

    * added ability to load *.mat files saved with GraphBLAS v3.
    * GrB_wait: added #pragma omp flush after any GrB_wait

Version 4.0.1, Jan 4, 2021

    * substantial performance gains: compared with v3.3.3: up to 5x faster in
        BFS (with LAGraph_bfs_parent2), 2x faster in Betweeness-Centrality (in
        LAgraph_bc_bactch5); BC now faster than GAP for kron, urand, and
        twitter (the 3 largest matrices in the GAP benchmark).
    * GrB_wait(), with no inputs: removed
    * GrB_wait(&object): polymorphic function added
    * GrB_*_nvals: no longer guarantees completion; use GrB_wait for that
    * GrB_error: now has two parameters: a string (char **) and an object
        The no-input GrB_error(void) method has been deprecated and removed.
    * GrB_Matrix_reduce_BinaryOp: limited to certain built-in ops.
        Support for user-defined operators and binary ops that do not
        correspond to built-in monoids has been deprecated and removed.
    * GrB_*_extractTuples: may return indices out of order
    * removed internal features: GBI iterator, slice and hyperslice matrices
    * bitmap/full matrices and vectors added: faster and lower memory usage
        when many entries present in a matrix or vector
    * GxB_SPARSITY_CONTROL, GxB_SPARSITY_STATUS added: for matrix get/set
    * positional operators and semirings: GxB_FIRSTI_INT32 and related ops
    * jumbled matrices: sort left pending, like zombies and pending tuples
    * GxB_get/set: added GxB_SPARSITY_* (hyper, sparse, bitmap, or full)
    * GxB_HYPER: enum renamed to GxB_HYPER_SWITCH
    * GxB_BITMAP_SWITCH added: for matrix/vector get/set and global get/set
    * GxB*import/export: API modified
    * GxB_SelectOp: nrows and ncols removed from function signature
    * OpenMP tasking removed from mergesort: just as fast; now ports to Windows
    * GxB_BURBLE added: for diagnostic output
    * (21) bug fix: A({lo,hi})=scalar in GrB; A(lo:hi)=scalar was OK

Version 3.3.3, July 14, 2020

    * (20) bug fix: w<mask>=A*u with mask non-empty and u empty (issue #13).
        affects mxm (A*B when B is a vector), vxm, and mxv.

Version 3.3.2, July 3, 2020

    * minor changes to build system
    * GraphBLAS v3.3.2 released as part of SuiteSparse v5.8.0

Version 3.3.1, June 30, 2020

    * (19) bug fix: incorrect typecasting when GrB_assign or GxB_subassign
        is simple: C=A where A is sparse or dense, in GB_dense_subassign_24.
        Bug introduced in v3.2.0.
    * revised gbmake: to allow GraphBLAS to be compiled in Octave

Version 3.3.0, June 26, 2020

    * GrB_wait( ): with no input arguments, has been deprecated.  It will
        be removed in V4.0.
    * added complex types: GxB_FC32 and GxB_FC64, many unary operators,
        binary operators, monoids, and semirings
    * added GrB_*_apply_BinaryOp1st and 2nd: also GxB version with GxB_Scalar
    * added bitwise operators: and their monoids and semirings
    * added predefined GrB* monoids and semirings: from the v1.3 spec.
    * GrB interface: added complex matrices and operators, bitwise
        operators; improved performance
    * changed typecasting rules: for casting floating point types to integers
    * added GrB_*_wait: wait for specific object to complete
    * added GrB_*_resize: same as prior GxB_*_resize functions
    * added GrB_kronecker: same as prior GxB_kron
    * added version methods: GrB_getVersion, GRB_VERSION, GRB_SUBVERSION
    * added GrB_*_removeElement
    * (18) bug fix: fixed typecasting in GB_dense_subassign_23, generic case
    * (17) bug fix: non-polymorphic GrB_eWiseAdd and eWiseMult functions
        were misnamed.

Version 3.2.2, Apr 2, 2020

    * (16) bug fix to GrB interface: for matrices with dimension > 2^53.
    * port to Microsoft Visual Studio: including GraphBLAS/Demo and
        GraphBLAS/Test, which had not been ported in v3.1.2.
    * remove dependency on m4: end-users no longer need m4;  still needed by
        the Source/codegen*.m scripts but those are for development only.

Version 3.2.1, Mar 10, 2020

    * GAP benchmarks in *.m in GraphBLAS/GraphBLAS/GAP (all but CC).
    * atomic read/write: faster atomics for icc (see Source/GB_atomics.h)
    * install name for Mac: in alternative/Makefile and Tcov/Makefile
    * enable -DGBCOMPACT from CMake: for faster Travis builds
    * GrB interface: better error message in GrB.reduce
    * GrB triangle count: added sorting heuristic in GrB.tricount.
    * bug fix for GraphBLAS/Demo/simple_timer: better selection of which
        timer to use; simple_timer.[ch] made consistent.
    * no bug fixes needed in primary GraphBLAS library: just in Demo, test,
        and alternative/Makefile.

Version 3.2.0, Feb 20, 2020

    * GxB_*_define for user-defined compile-time objects: removed.  Not
        compatible with the faster kernels for mxm and dense matrices/vectors.
        Use the GrB_*_new functions in the GraphBLAS C API Specification
        instead.
    * faster saxpy-based matrix multiply (about 5x to 10x for mxv and vxm):
        removed Sauna workspace.  Heap method removed.  Hash method added.
    * better performance for dense matrix and vectors: NOTE: see bug (19) above
    * faster typecast of the mask matrix M: GB_mcast replaces cast_M
    * added GB_BURBLE: for development diagnostics
    * changed default chunk size: from 4K to 64K
    * added the PAIR binary operator: f(x,y)=1
    * added the ANY binary operator: f(x,y)=x, or f(x,y)=y ; arbitrary choice
    * added structural mask: from v1.3 C API Specification
    * added GrB_DESC_*: predefined descriptor, from v1.3 C API Specification
    * many atomics added: for the faster matrix multiply.  These changes have
        not been ported to Microsoft Visual Studio, which only supports a
        subset of "#pragma omp atomic" statements.  This will be resolved in a
        future version; in the meantime, use v3.1.2 with MS Visual Studio
        instead of v3.2.0.
    * no bug fixes

Version 3.1.2, Dec 16, 2019

    * (15) bug fix in parallel matrix-matrix multiply: could occur when # of
        threads is larger than the # of columns of B, for C=A*B, and when
        B is a standard matrix with one or more empty vectors.
    * (14) bug fix for GrB interface: A(58) and A(:) were conflated.
    * compiler port: changes to allow GraphBLAS to be compiled with older
        compilers (pre C11), and Microsoft Visual Studio.

Version 3.1.1, Oct 21, 2019

    * minor edits: user guide and comments in code

Version 3.1.0, Oct 2, 2019

    * added GrB interface: GraphBLAS/GraphBLAS is new.  In Source/, added
        global pointer to printf for mexPrintf, pointer to
        mexMakeMemoryPersistent for Sauna workspace.  Changed how GraphBLAS
        objects are printed with GxB_print.  Changed how duplicate indices are
        handled in assign and extract, to match the built-in stadard.
        Added helper functions.
        Code size: GrB is 9.7KLOC, test/ is 4.5KLOC).
    * bug counter added to this ChangeLog: to count # of bugs that appeared
        in formal releases that affect production code.  The count excludes
        bug fixes for test code, bugs in the demo codes, bugs introduced
        in beta versions that were fixed before any formal release, and
        bugs prior to version 1.0.  Code size of Source/, Include/ excluding
        Source/Generated, and Config/*.m4, is 42,659 lines (not including the
        new GrB interface).  13 bugs / 42K lines is a bug rate of 0.3 bugs
        per KLOC, much lower than most commercial software, but higher than
        UMFPACK, CHOLMOD, etc (with about 0.1 bug per KLOC).  GraphBLAS is a
        much more complex library, from the external view, than solving Ax=b.
        If UMFPACK has a bug, then Ax-b is typically large; there is no
        'residual' to check for GraphBLAS.  Also, in GraphBLAS, the test suite
        has about the same size as the main library (32K lines in Test/ and
        Tcov/).  For UMFPACK, etc, the test suite is always about 1/3 the size
        of the library itself.
    * 'make dox': for doxygen removed (not really that useful)
    * (13) bug fix to GB_reduce_to_vector: to avoid integer divide-by-zero for
        a matrix with n=0 columns.
    * (12) bug fix to GB_accum_mask: when C+=T if C has no entries except
        pending tuples
    * (11) bug fix to GB_resize: when pending tuples exist and vdim is growing
        from vdim <= 1 to vdim > 1, matrix must be finished first.
    * (10) bug fix to GB_subref_phase1: "int nI" parameter should be int64_t.

Version 3.0.1, July 26, 2019

    * version number: Three changes to the user-visible API are not
        backward-compatible with V2.x: the added parameters to GxB_init and
        GxB_SelectOp_new, and the change in the type of the Thunk argument for
        GxB_select.  Thus, the SO version of SuiteSparse:GraphBLAS is now 3, no
        longer 2.  This change only affects SuiteSparse:GraphBLAS GxB_*
        extenstions, not any GrB_* functions or definitions.
    * added GxB_Scalar: acts like a GrB_Vector of length 1.
    * OpenMP parallelism: added nthreads and chunk parameters to GxB_set/get.
    * added parameter to GxB_init: bool user_malloc_is_thread_safe,
        for the GrB mexFunction interface, or any other malloc library that
        might not be thread-safe.  mxMalloc is not thread-safe.
        This change is not backward compatible with Version 2.x.
    * changed thunk parameter of GxB_select:  was (void *), now GxB_Scalar.
        This change is not backward compatible with Version 2.x.
    * added parameter to GxB_SelectOp_new: to specify the type of the Thunk.
        This change is not backward compatible with Version 2.x.
    * added options to GxB_get: determine if a matrix is hypersparse or not,
        global library, API information, nthreads, and chunk.
    * added options to GxB_set: nthreads, and chunk.
    * new operators and semirings: RDIV (f(x,y)=y/x) and RMINUS (y-x)
        binary operators.

Version 2.3.5, July 20, 2019

    * minor update: fix for tests in R2019b

Version 2.3.4, July 4, 2019

    * Collected Algorithm of the ACM
    * (9) minor bug fix to GrB_*_extractTuples: nvals was left unchanged
        if the matrix or vector had no entries (now returned as zero).

Version 2.3.3, May 27, 2019

    * minor changes to the documentation: no change to the code

Version 2.3.2, Mar 18, 2019

    * GxB_Matrix_Option_set: removed spurious check of input matrix

Version 2.3.1, Mar 9, 2019

    * _Generic:  further modifications for 'int' vs 'const int', needed for
        icc 19.0.0.
    * (8) bug fix in user_def1.m4: compile-time GxB_Semring_define with
        terminal monoids

Version 2.3.0, Feb 25, 2019

    * early exit: for integer TIMES monoids (terminal value is 0);
        cannot use zero for floating-point, to preserve NaN behavior
    * GrB_assign / GxB_subassign: further exploit of aliased inputs
    * Test/: GrB mexFunctions now link against the dynamic -lgraphblas
    * bug fix for Demo/mis*: random number generator could create
        duplicate scores, which leads to a stall
    * terminal values for user monoids: added GxB_Monoid_terminal_new,
        GxB_Monoid_terminal_define, and GxB_Monoid_terminal
    * added GxB_init: GrB_init with malloc/calloc/realloc/free redefinition
    * _Generic: compilers differ on _Generic(x,int:,const int:). gcc, clang,
        icc 18.0.0 treat int and const int the same; icc 18.0.3 treats them
        as different.  This is a result of an ambiguity in the C11
        specification.  Minor update so that the use of _Generic(...) is
        compatible with all compilers.
    * early exit: for GrB_reduce

Version 2.3.0 (BETA1), Feb 16, 2019

    * simplified GBI_*_iterators
    * towards OpenMP: PARALLEL comments added to most files (all upper case)
        where parallelism will be added in the future.
    * early exit: for monoids: MIN, MAX, AND, OR, based on terminal values
    * Demo/bfs*: much faster (prior versions had performance bug)
    * GrB_assign for accum/mask step: faster, zombies and pending tuples
        exploited by C<M>=accum(C,T) for any GraphBLAS method, when either the
        mask M or accum are present.
    * moved persistent thread-workspace from the matrix to a global array
    * added isequal function to Demos/
    * added import/export method
    * added nthreads: to descriptor, the matrix, and a global nthreads
        setting, and added Context as parameter in many internal
        functions, to pass in Context->nthreads for future parallelism
    * defined all enum constants explicitly: no change to their values,
        this just ensures they remain fixed in future versions

Version 2.2.3, Dec 30, 2018

    * added doxygen documentation: minor changes to the code
        comments to accomodate doxygen.  Added Doxyfile settings file.

Version 2.2.2, Dec 18, 2018

    * GxB_print: better output for compile-time user objects
    * (7) bug fix: for GxB_Type_define, for GrB_*_build.
    * (6) bug fix: for GxB_Semiring_define, which was unable to access
        the predefined GxB_*_BOOL_MONOIDs.

Version 2.2.0, Nov 29, 2018

    * identical to 2.2.0 (BETA4): date changed, and "BETA4" removed.
        Demo/choldemo removed (testing artifact, not needed).

Version 2.2.0 (BETA4), Nov 28, 2018

    * minor change to GxB_get, GxB_set (all functions using va_arg):
        const removed from parameter definitions to silence spurious warnings
        from clang version 10.0.0, Mac OSX 10.14.
    * added Doc/CONTRIBUTOR-LICENSE.txt
    * added Doc/README_Doc.txt: includes instructions for OpenMP on the Mac
    * minor changes to comments of GB_subref_template: to match the ACM TOMS
        paper discussion of GrB_extract
    * included the GraphBLAS Extras: triangle counting, k-truss, and
        Kronecker matrix generator
    * minor changes for gcc -Wall -Wpedantic -Wextra, and icc -w3: to fix or
        silence warnings.  In a few cases, prior versions were relying on
        extensions to the C11 standard in gcc, clang, xlc.  The extensions
        are widely supported but best avoided anway.

Version 2.2.0 (BETA3), Nov 23, 2018

    * removed persistent thread-local O(n) workspace:  the Mark,
        Flag, and Work arrays in GB_thread_local in prior versions are removed.
        Replaced with temporary workspace, except for C=A*B using Gustavson's
        method, which now uses the C->Sauna workspace, held in the output
        matrix.
    * better support for user-application threads: GrB_finalize is now fully
        compliant with the spec.  User applications can use POSIX or OpenMP
        threads, or no threading, and use GraphBLAS in a thread-safe manner.
        Added OpenMP and POSIX pthread demos.
    * bug fix: freeing an object (monoid, matrix, or vector) that is
        dependent on another user-defined objects (an operator or type) that
        has already been freed led to the reading of an invalid value: the size
        of the object.  This only affects the memory usage statistics for
        testing only, not production use.
    * beta bug fix: memory leak in pagerank_demo program (bug first appears in
        2.2.0BETA2, not in any non-BETA final release

Version 2.2.0 (BETA2), Nov 15, 2018

    * added additional pagerank example in Demo/
    * beta bug fix: GxB_Monoid_define: bug fix for C struct types.  bug first
        appears in Version 2.2.0 (BETA1), not in any non-BETA final release.

Version 2.2.0 (BETA1), Nov 2, 2018

    * added GxB_*_define: to create user-defined objects at compile-time.
        All internal macros renamed to add the GB_ prefix, to help avoid
        name conflict with possible user-defined objects and macros.
    * changed default format to GxB_BY_ROW
    * performance improvements to GrB*assign* and GrB*extract
    * added PageRank demos
    * added GxB_*print: to display all GraphBLAS objects

Version 2.1.0, Oct 14, 2018

    * identical to V2.1.0 BETA2: except for a minor update to the user guide,
        and date of release

Version 2.1.0 (BETA2), Sept 17, 2018

    * user function z=f(x,y): passed to GrB_BinaryOp_new, may now be called as
        z=f(z,y), with x and z aliased.  This is permitted by the API
        specification, and greatly improves performance of user-defined
        semirings.

Version 2.1.0 (BETA1), Sept 11, 2018

    * major update: added hypersparse and CSR formats, colon notation, and
        user selection of the method used by C=A*B.  All changes to the API are
        backward compatible with Version 2.0, so the SO version does not
        increase (it is still 2.x).
    * added GxB_AxB_METHOD: for user selection of C=A*B method
    * added GxB_RANGE, GxB_STRIDE and GxB_BACKWARDS: for colon
        notation: begin:end and begin:inc:end.
    * added GxB_*Option* functions: to control hypersparsity and CSR/CSC format
    * added GxB_set and GxB_set: to set/get the descriptor and other options
    * (5) bug fix: if the accum operator z=f(x,y) was user-defined with
        different built-in types for x, y, z, the typecasting was wrong
    * GXB_* macros renamed GxB_*: old ones kept for backward compatibility

Version 2.0.3: July 4, 2018

    * (4) bug fix to GxB_resize
    * improvements to CMake script: version now defined only in CMakeLists.txt,
        and then cmake configures Include/GraphBLAS.h, README, and User Guide
    * bfs5 demo: asymptotically faster using sparse vector v but somewhat
        slower if entire graph is traversed

Version 2.0.2: June 25, 2018

    * added -lm to library dependency
    * minor changes to demos and user guide
    * removed unused code from Generated/* semiring functions

Version 2.0.1: Mar 15, 2018

    * (3) bug fix in GxB_kron: computed C incorrectly when A and B had pending
        updates on input

Version 2.0.0: Mar 12, 2018

    * moved opaque object definitions from Include/GraphBLAS.h to Source/GB.h
    * modifications to meet changes in the Nov 14, 2017, API specification:
        GrB_Monoid_TYPE_new changed to GrB_Monoid_new_TYPE.
        GrB_Type_new modified: 2nd argument no longer a type, but sizeof(type).
        This change is not backward compatible with Version 1.x, so this
        required an increase in the SO version, so the version number increased
        from 1.x to 2.x.
    * to allow non-C applications to access all GraphBLAS functions:
        These were just macros, now defined as both macros and functions:
        GrB_Type_new, GrB_UnaryOp_new, GrB_BinaryOp_new, and GxB_SelectOp_new.
    * added GxB_kron, GxB_resize (GxB_Matrix_resize and GxB_Vector_resize)
    * (2) bug fix to mask:  GrB_anymethod (C, C, ... , r_desc) where r_desc.outp
        is 'replace', and C is aliased to the Mask, was incorrect.

Version 1.1.2: Dec 28, 2017

    * build issues with cmake
    * performance improvement of dot product method, C=A'*B and v=u'*A,
        particularly when A, B and u have dense columns, or nearly dense
        columns.

Version 1.1.1: Dec 17, 2017

    * (1) bug fix to GrB_assign and GxB_subassign: result was incorrect when
        output C was the same as the input A or Mask.
    * performance improvement in C<M>=A*B and GrB_reduce to scalar
    * split AxB built-in semirings into Source/Generated/* for
        faster compilation
    * added memory usage statistics

Version 1.1.0: Dec 1, 2017

    * add new feature: GxB_SelectOp operator and GxB_select operation
    * to clarify which features of SuiteSparse:GraphBLAS are extensions to
        the spec, the names of functions and objects not in the spec have
        changed.  They are now GxB_* (GXB_ for macros).
    * modified how the global matrix queue is accessed: for thread safety
        in case the user application is multi-threaded

Version 1.0.0: Nov 25, 2017

    * transition to CMake
    * tested on many compilers: gcc 4.9 to 7.2 on Linux, clang 8 and gcc 6.2.0
        on the Mac, xlc 13.01 on IBM Power)
    * changed printf formats in Demo/ to silence warnings from older compilers
    * complex.h in gcc-6.2.0 on the Mac doesn't #define CMPLX;
        added to usercomplex.h
    * mergesort removed, quicksort performance improved
    * performance improvement for masked matrix-matrix multiply
    * bug fix for masked matrix-matrix multiply. In 0.5.0 only the Mask
        structure was used, not the values.  The spec requires the values of
        the Mask.  This is a bug but into only affects masked matrix multiply
        when the Mask has explicit zero entries.

Version 0.5.0: Nov 13, 2017

    * resolved icc -O3 segfault: Intel compiler bug fixed icc version 18.0
    * added triangle-counting demo: in C (Demo/tricount.c) and
        Test/tricount.m.  See also Test/test69, Test/test70. and Test/test71.
    * performance enhancements to GrB_eWiseMult, GrB_assign, GrB_subassign,
        GrB_extract, and GrB_mxm, reducing time and memory.  mxm now exploits
        the mask during computation, to save memory and often saving time.
        This is essential for good performance for triangle counting.
    * reduced Test/testall.m and Tcov/testcov.m testing time from 2 hours to
        15 minutes, maintained 100% test coverage

Version 0.4.0: Oct 24, 2017

    * SPEC: SuiteSparse:GraphBLAS 0.4.0 fully conforms to 1.1.0 of the spec
    * GrB_assign functions added; all now conform to the 1.1.0 spec
    * renamed all prior GrB_*_assign functions to GrB_*_subassign

Version 0.3.0: Oct 14, 2017

    * changes for spec 1.1.0
    * performance improvement of GrB_mxm, GrB_mxv, transpose, GrB_reduce;
        added workspace kept internally, reused for subsequent calls to
        GraphBLAS
    * performance improvement of bfs in Demo (v held as dense vector)
    * performance improvement of GrB_assign when A is a scalar
    * performance improvement of C<M>= ... mask operation
    * GrB_Column_extract and GrB_Column_assign renamed GrB_Col_*
        to match changes in the spec
    * changed GrB_*_setElement and GrB_*_extractTuples to match the spec
    * added GrB_INSUFFICIENT_SPACE error code for GrB_*_extractTuples
    * added GrB_INVALID_HANDLE
    * GrB_assign still does not match the spec (in progress).
        It differs on how it treats entries outside C(I,J), and it differs
        in the size and interpretation of the Mask.

Version 0.2.0: Sept 5, 2017

    * No significant change to the code; but preparing for wider release
    * content of GrB_stddef.h moved into Include/GraphBLAS.h and file removed
    * User Guide updated (SPEC discussion)
    * GraphBLAS.h modified (SPEC discussions)
    * Licensed under Apache 2.0; versions 0.1.x were limited releases
    * removed wathen_mod.m

Version 0.1.2: Aug 30, 2017

    * added (double) to fpclassify in CAST macro, to silence
        spurious errors in gcc
    * minor typos
    * icc -O3 causes a segfault when compiling GB_AxB_builtin.c, so
        Lib/GraphBLAS_config.mk now uses -O2 with icc.
    * some versions of gcc have trouble finding libgraphblas.so.0
        when compiling the Demo (if GraphBLAS is not installed with
        'make install').  Instead of requiring a 'make install'
        static linking is now used for the Demo programs.  This
        has no effect on the GraphBLAS library itself.
    * changes for GraphBLAS spec 1.0.2 (Aug 10, 2017 version):
        * GrB_Vector_reduce_Monoid renamed to GrB_Matrix_reduce_Monoid
        * GrB_Vector_reduce_BinaryOp renamed to GrB_Matrix_reduce_BinaryOp
        * GrB_Row_extract was renamed in the spec to GrB_Col_extract, but
            this version keeps the name GrB_Column_extract since it parallels
            the name GrB_Column_assign.

Version 0.1.1: Aug 28, 2017

    * minor changes to Makefiles and GraphBLAS_config.mk
    * port to Linux with gcc 4.9.3, 5.40, and 6.3.0
    * minor code changes to silence spurious gcc warnings;
        (&Ax[i]) changed to (Ax +(i)).
    * bug fix to GB_assign1.c (apply_pending_updates variable)

Version 0.1.0: July 31, 2017

    * first version released; only to GraphBLAS API Committee

