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
    * (32) 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_*_memoryUsage 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 ANSI 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 ANSI 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 ANSI 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

