GraphBLAS v10 container methods, testing

Author: DrTimothyAldenDavis

GraphBLAS/Doc/GraphBLAS_UserGuide.pdf

@@ -256,7 +256,7 @@ \subsubsection{OpenMP parallelism}
 \begin{verbatim}
     bool have_openmp ;
     GrB_get (GrB_GLOBAL, &have_openmp, GxB_LIBRARY_OPENMP) ;
-    if (!have_openmp) printf ("GraphBLAS not compiled with OpenMP\n") : \end{verbatim}}
+    if (!have_openmp) printf ("GraphBLAS not compiled with OpenMP\n") ; \end{verbatim}}
 
 Compiling GraphBLAS without OpenMP is not recommended for installation in a
 package manager (Linux, conda-forge, spack, brew, vcpkg, etc).

GraphBLAS/Doc/UserGuide/GrB_get_set_Global.tex

@@ -106,7 +106,7 @@ \subsubsection{{\sf GxB\_Vector\_load:} load data into a vector}
 \verb'V' becomes \verb'n', and its type is changed to match the \verb'type'
 parameter.
 
-After this method returns, \verb'GrB_Vector_size' and \verb'GrB_Vector_nvals' 
+After this method returns, \verb'GrB_Vector_size' and \verb'GrB_Vector_nvals'
 will both return \verb'n'.  That is, the vector \verb'V' is a dense vector.
 It is held in the \verb'GxB_FULL' data format, in \verb'GrB_COLMAJOR'
 orientation.
@@ -234,7 +234,7 @@ \subsubsection{{\sf GxB\_Container\_new:} create a container}
 
 \begin{itemize}
 \item \verb'nrows': the number of rows of a matrix, or the size of a vector.
-\item \verb'ncols': the number of columns of a matrix, or 1 for a vector. 
+\item \verb'ncols': the number of columns of a matrix, or 1 for a vector.
 \item \verb'nrows_nonempty':  if known, this value must give the exact number
     of non-empty rows of a matrix or vector (that is, the number of
     rows have at least one entry).  If not known, this value must be
@@ -258,7 +258,7 @@ \subsubsection{{\sf GxB\_Container\_new:} create a container}
 \item \verb'jumbled': if true, the indices in any given row (if in row-major
     orientation) or column (if column-major) may appear out of order.
     Otherwise, they must appear in ascending order.
-    A jumbled matrix or vector must not have any read-only components. 
+    A jumbled matrix or vector must not have any read-only components.
 \end{itemize}
 
 The Container holds five dense \verb'GrB_Vector' objects that hold the primary
@@ -305,6 +305,10 @@ \subsubsection{{\sf GxB\_load\_Matrix\_from\_Container:} load a matrix from a co
 \verb'GxB_load_Matrix_from_Container' moves all of the data from a
 \verb'GxB_Container' into a \verb'GrB_Matrix' in O(1) time.
 
+The container vectors \verb'p', \verb'h', and \verb'i' may be any signed or
+unsigned integer type of size 32 or 64 bits.  Any other types will result in
+an error.
+
 %-------------------------------------------------------------------------------
 \subsubsection{{\sf GxB\_load\_Vector\_from\_Container:} load a vector from a container}
 %-------------------------------------------------------------------------------
@@ -326,6 +330,11 @@ \subsubsection{{\sf GxB\_load\_Vector\_from\_Container:} load a vector from a co
 \verb'GxB_load_Vector_from_Container' moves all of the data from a
 \verb'GxB_Container' into a \verb'GrB_Vector' in O(1) time.
 
+The container format may not be \verb'GxB_HYPERSPARSE'.
+The container vectors \verb'p' and \verb'i' may be any signed or
+unsigned integer type of size 32 or 64 bits.  Any other types will result in
+an error.
+
 \newpage
 %-------------------------------------------------------------------------------
 \subsubsection{{\sf GxB\_unload\_Matrix\_into\_Container:} unload a matrix into a container}
@@ -347,6 +356,9 @@ \subsubsection{{\sf GxB\_unload\_Matrix\_into\_Container:} unload a matrix into
 \verb'GxB_unload_Matrix_into_Container': moves all of the data from
 a \verb'GrB_Matrix' into a \verb'GxB_Container' in O(1) time.
 
+The container vector \verb'p' is unloaded as \verb'GrB_UINT32' or \verb'GrB_UINT64',
+while \verb'h', and \verb'i' are unloaded as \verb'GrB_INT32' or \verb'GrB_INT64'.
+
 %-------------------------------------------------------------------------------
 \subsubsection{{\sf GxB\_unload\_Vector\_into\_Container:} unload a vector into a container}
 %-------------------------------------------------------------------------------
@@ -367,12 +379,15 @@ \subsubsection{{\sf GxB\_unload\_Vector\_into\_Container:} unload a vector into
 \verb'GxB_unload_Vector_into_Container': moves all of the data from
 a \verb'GrB_Vector' into a \verb'GxB_Container' in O(1) time.
 
+The container vector \verb'p' is unloaded as \verb'GrB_UINT32' or \verb'GrB_UINT64',
+while \verb'i' is unloaded as \verb'GrB_INT32' or \verb'GrB_INT64'.
+
 %-------------------------------------------------------------------------------
 \subsubsection{Container example: unloading/loading an entire matrix into C arrays}
 %-------------------------------------------------------------------------------
 \label{container_example}
 
-The following example unloads a 
+The following example unloads a
 \verb'GrB_Matrix A' of size \verb'nrows'-by-\verb'ncols',
 with \verb'nvals' entries, of type \verb'xtype'.  The example takes will take O(1) time,
 and the only \verb'mallocs' are in \verb'GxB_Container_new' (which can be reused for
@@ -505,7 +520,7 @@ \subsubsection{Container example: unloading/loading, but not using C arrays}
     ...
     GxB_unload_Vector_into_Container (Delta, Container, desc) ;
     GxB_Matrix_build_Vector (DeltaMatrix, Container->i, J_vector,
-        Container->x, GrB_PLUS_FP32, NULL) :
+        Container->x, GrB_PLUS_FP32, NULL) ;
     GxB_load_Vector_from_Container (Delta, Container, desc) ;
 }
 GxB_Container_free (&Container) ;

GraphBLAS/Doc/UserGuide/GrB_objects_Container.tex

@@ -202,7 +202,7 @@ mxArray *gb_export_to_mxsparse  // return exported MATLAB sparse matrix S
 
         // ensure the types are correct; this 'cannot' fail but check anyway
         CHECK_ERROR (Tp_type != GrB_UINT64, "internal error 901") ;
-        CHECK_ERROR (Ti_type != GrB_UINT64, "internal error 902") ;
+        CHECK_ERROR (Ti_type != GrB_INT64, "internal error 902") ;
         CHECK_ERROR (Tx_type != type, "internal error 903") ;
 
         //----------------------------------------------------------------------

GraphBLAS/GraphBLAS/@GrB/private/util/gb_export_to_mxsparse.c

@@ -230,7 +230,7 @@ mxArray *gb_export_to_mxstruct  // return exported MATLAB struct G
         mxSetFieldByNumber (G, 0, 3, Ap_mx) ;
 
         // export the indices
-        mxClassID Ai_class = (Ai_type == GrB_UINT32) ?
+        mxClassID Ai_class = (Ai_type == GrB_INT32 || Ai_type == GrB_UINT32) ?
             mxUINT32_CLASS : mxUINT64_CLASS ;
         mxArray *Ai_mx = mxCreateNumericMatrix (1, 0, Ai_class, mxREAL) ;
         if (Ai_size > 0)
@@ -252,7 +252,7 @@ mxArray *gb_export_to_mxstruct  // return exported MATLAB struct G
     }
     mxSetFieldByNumber (G, 0, 2, Ax_mx) ;
 
-    mxClassID Ah_class = (Ah_type == GrB_UINT32) ?
+    mxClassID Ah_class = (Ah_type == GrB_INT32 || Ah_type == GrB_UINT32) ?
         mxUINT32_CLASS : mxUINT64_CLASS ;
 
     if (sparsity_status == GxB_HYPERSPARSE)

GraphBLAS/GraphBLAS/@GrB/private/util/gb_export_to_mxstruct.c

@@ -14,6 +14,16 @@
 #include "GB_container.h"
 #define GB_FREE_ALL GB_phybix_free (A) ;
 
+static inline bool GB_type_ok (GrB_Type type)
+{
+    return (type == GrB_INT32 || type == GrB_UINT32 ||
+            type == GrB_INT64 || type == GrB_UINT64) ;
+}
+
+//------------------------------------------------------------------------------
+// GB_load_from_container
+//------------------------------------------------------------------------------
+
 GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
 (
     GrB_Matrix A,               // matrix to load from the Container
@@ -62,7 +72,8 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
     GrB_Type Ap_type = NULL, Ah_type = NULL, Ab_type = NULL, Ai_type = NULL ;
     uint64_t Ah_size = 0, Ap_size = 0, Ai_size = 0, Ab_size = 0, Ax_size = 0 ;
     uint64_t nrows_times_ncols = UINT64_MAX ;
-    bool ok = GB_uint64_multiply (&nrows_times_ncols, nrows, ncols) ;
+    bool okb = GB_uint64_multiply (&nrows_times_ncols, nrows, ncols) ;
+    bool ok = true ;
     bool jumbled = Container->jumbled ;
 
     // determine the A->j_is_32 condition when Container->h is empty
@@ -103,6 +114,7 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
             GB_OK (GB_vector_unload (Container->p, &(A->p), &Ap_type,
                 &plen1, &Ap_size, &(A->p_shallow), Werk)) ;
             A->p_size = (size_t) Ap_size ;
+            ok = GB_type_ok (Ap_type) ;
 
             // load or create A->h
             if (h_empty)
@@ -127,6 +139,7 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
                     &plen, &Ah_size, &(A->h_shallow), Werk)) ;
             }
             A->h_size = (size_t) Ah_size ;
+            ok = ok && GB_type_ok (Ah_type) ;
 
             // load A->Y
             A->Y = Container->Y ;
@@ -139,14 +152,15 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
             GB_OK (GB_vector_unload (Container->i, &(A->i), &Ai_type,
                 &Ai_len, &Ai_size, &(A->i_shallow), Werk)) ;
             A->i_size = (size_t) Ai_size ;
+            ok = ok && GB_type_ok (Ai_type) ;
 
             // define plen, nvec, and jumbled
             A->plen = plen ;
             A->nvec = plen ;
             A->jumbled = jumbled ;
 
             // basic sanity checks
-            if (plen1 != plen + 1 ||
+            if (!ok || plen1 != plen + 1 ||
                 !(A->nvec >= 0 && A->nvec <= A->plen && A->plen <= A->vdim))
             { 
                 GB_FREE_ALL ;
@@ -164,6 +178,7 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
             GB_OK (GB_vector_unload (Container->p, &(A->p), &Ap_type,
                 &plen1, &Ap_size, &(A->p_shallow), Werk)) ;
             A->p_size = (size_t) Ap_size ;
+            ok = GB_type_ok (Ap_type) ;
 
             // clear Container->h, Y, and b
             GB_vector_reset (Container->h) ;
@@ -174,14 +189,15 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
             GB_OK (GB_vector_unload (Container->i, &(A->i), &Ai_type,
                 &Ai_len, &Ai_size, &(A->i_shallow), Werk)) ;
             A->i_size = (size_t) Ai_size ;
+            ok = ok && GB_type_ok (Ai_type) ;
 
             // define plen, nvec, and jumbled
             A->plen = plen1 - 1 ;
             A->nvec = A->plen ;
             A->jumbled = jumbled ;
 
             // basic sanity checks
-            if (!(A->nvec == A->plen && A->plen == A->vdim))
+            if (!ok || !(A->nvec == A->plen && A->plen == A->vdim))
             { 
                 GB_FREE_ALL ;
                 return (GrB_INVALID_VALUE) ;
@@ -212,7 +228,7 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
             A->nvec = A->vdim ;
 
             // basic sanity checks
-            if (Ab_type != GrB_INT8 || !ok || Ab_len < nrows_times_ncols)
+            if (Ab_type != GrB_INT8 || !okb || Ab_len < nrows_times_ncols)
             { 
                 GB_FREE_ALL ;
                 return (GrB_INVALID_VALUE) ;
@@ -246,9 +262,9 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
     A->x_size = (size_t) Ax_size ;
 
     // define the integer types
-    A->p_is_32 = (Ap_type == GrB_UINT32) ;
-    A->j_is_32 = (Ah_type == GrB_UINT32) ;
-    A->i_is_32 = (Ai_type == GrB_UINT32) ;
+    A->p_is_32 = (Ap_type == GrB_UINT32 || Ap_type == GrB_INT32) ;
+    A->j_is_32 = (Ah_type == GrB_UINT32 || Ah_type == GrB_INT32) ;
+    A->i_is_32 = (Ai_type == GrB_UINT32 || Ai_type == GrB_INT32) ;
 
     //--------------------------------------------------------------------------
     // more basic sanity checks
@@ -270,14 +286,14 @@ GrB_Info GB_load_from_container // GxB_Container -> GrB_Matrix
         // A->x must have size >= A->nvals for non-iso sparse/hypersparse
         ok = (Ax_len >= A->nvals) ;
     }
-    else
+    else // A is full or bitmap
     { 
         // A->x must have size >= nrows*ncols for non-iso full/bitmap
-        ok = ok && (Ax_len >= nrows_times_ncols) ;
+        ok = okb && (Ax_len >= nrows_times_ncols) ;
     }
 
     // ensure Ai_len is the right size
-    if (format == GxB_HYPERSPARSE || format == GxB_SPARSE)
+    if (format == GxB_HYPERSPARSE || format == GxB_SPARSE && ok)
     { 
         // A->i must have size >= A->nvals for sparse/hypersparse
         ok = ok && (Ai_len >= A->nvals) ;

GraphBLAS/Source/container/GB_load_from_container.c

@@ -77,10 +77,10 @@ GrB_Info GB_unload_into_container   // GrB_Matrix -> GxB_Container
                 A->p_is_32 ? GrB_UINT32 : GrB_UINT64,
                 A->nvec+1, A->p_size, A->p_shallow) ;
             GB_vector_load (Container->h, &(A->h),
-                A->j_is_32 ? GrB_UINT32 : GrB_UINT64,
+                A->j_is_32 ? GrB_INT32 : GrB_INT64,
                 A->nvec, A->h_size, A->h_shallow) ;
             GB_vector_load (Container->i, &(A->i),
-                A->i_is_32 ? GrB_UINT32 : GrB_UINT64,
+                A->i_is_32 ? GrB_INT32 : GrB_INT64,
                 nvals, A->i_size, A->i_shallow) ;
             break ;
 
@@ -91,7 +91,7 @@ GrB_Info GB_unload_into_container   // GrB_Matrix -> GxB_Container
                 A->p_is_32 ? GrB_UINT32 : GrB_UINT64,
                 A->plen+1, A->p_size, A->p_shallow) ;
             GB_vector_load (Container->i, &(A->i),
-                A->i_is_32 ? GrB_UINT32 : GrB_UINT64,
+                A->i_is_32 ? GrB_INT32 : GrB_INT64,
                 nvals, A->i_size, A->i_shallow) ;
             break ;
 

GraphBLAS/Source/container/GB_unload_into_container.c

@@ -58,9 +58,9 @@ GrB_Info GxB_Container_new
     //--------------------------------------------------------------------------
 
     GB_OK (GB_container_component_new (&((*Container)->p), GrB_UINT32)) ;
-    GB_OK (GB_container_component_new (&((*Container)->h), GrB_UINT32)) ;
+    GB_OK (GB_container_component_new (&((*Container)->h), GrB_INT32)) ;
     GB_OK (GB_container_component_new (&((*Container)->b), GrB_INT8)) ;
-    GB_OK (GB_container_component_new (&((*Container)->i), GrB_UINT32)) ;
+    GB_OK (GB_container_component_new (&((*Container)->i), GrB_INT32)) ;
     GB_OK (GB_container_component_new (&((*Container)->x), GrB_BOOL)) ;
 
     //--------------------------------------------------------------------------