GrB_Info GxB_Vector_fprint // print and check a GrB_Vector ( GrB_Vector v, // object to print and check const char *name, // name of the object GxB_Print_Level pr, // print level FILE *f // file for output ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GxB_Vector_fprint (v, name, pr, f)") ; //-------------------------------------------------------------------------- // print and check the object //-------------------------------------------------------------------------- GrB_Info info = GB_Vector_check (v, name, pr, f, Context) ; //-------------------------------------------------------------------------- // return result //-------------------------------------------------------------------------- if (info == GrB_INDEX_OUT_OF_BOUNDS) { return (GB_ERROR (GrB_INVALID_OBJECT, (GB_LOG, "vector invalid: indices out of order [%s]", GB_NAME))) ; } else { return (info) ; } }
GrB_Info GrB_Matrix_apply // C<Mask> = accum (C, op(A)) or op(A') ( GrB_Matrix C, // input/output matrix for results const GrB_Matrix Mask, // optional Mask for C, unused if NULL const GrB_BinaryOp accum, // optional accum for Z=accum(C,T) const GrB_UnaryOp op, // operator to apply to the entries const GrB_Matrix A, // first input: matrix A const GrB_Descriptor desc // descriptor for C, Mask, and A ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GrB_Matrix_apply (C, Mask, accum, op, A, desc)") ; GB_RETURN_IF_NULL_OR_FAULTY (C) ; GB_RETURN_IF_FAULTY (Mask) ; GB_RETURN_IF_NULL_OR_FAULTY (A) ; // get the descriptor GB_GET_DESCRIPTOR (info, desc, C_replace, Mask_comp, A_transpose, xx1, xx2); //-------------------------------------------------------------------------- // apply the operator and optionally transpose; assemble pending tuples //-------------------------------------------------------------------------- return (GB_apply ( C, C_replace, // C and its descriptor Mask, Mask_comp, // Mask and its descriptor accum, // optional accum for Z=accum(C,T) op, // operator to apply to the entries A, A_transpose, // A and its descriptor Context)) ; }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { bool malloc_debug = GB_mx_get_global (true) ; GrB_Matrix A = NULL, E = NULL, L = NULL, U = NULL ; // check inputs GB_WHERE (USAGE) ; if (nargout > 2 || nargin != 5) { mexErrMsgTxt ("Usage: " USAGE) ; } #define GET_DEEP_COPY ; #define FREE_DEEP_COPY ; // get the method. Default is Sandia method (outer product) int GET_SCALAR (0, int, method, 3) ; // get A, E, L, and U A = GB_mx_mxArray_to_Matrix (pargin [1], "A", false, true) ; E = GB_mx_mxArray_to_Matrix (pargin [2], "E", false, true) ; L = GB_mx_mxArray_to_Matrix (pargin [3], "L", false, true) ; U = GB_mx_mxArray_to_Matrix (pargin [4], "U", false, true) ; // count the triangles double t [2] ; int64_t ntri ; METHOD (tricount (&ntri, method, A, E, L, U, t)) ; // return ntri to MATLAB pargout [0] = mxCreateDoubleScalar ((double) ntri) ; // return t to MATLAB (compute time) if (nargout > 0) { pargout [1] = mxCreateDoubleScalar (t [0] + t [1]) ; } FREE_ALL ; GrB_finalize ( ) ; }
GrB_Info GxB_Global_Option_set // set a global default option ( GxB_Option_Field field, // option to change ... // value to change it to ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GxB_Global_Option_set (field, value)") ; //-------------------------------------------------------------------------- // set the global option //-------------------------------------------------------------------------- va_list ap ; switch (field) { case GxB_HYPER : va_start (ap, field) ; GB_Global.hyper_ratio = va_arg (ap, double) ; va_end (ap) ; break ; case GxB_FORMAT : va_start (ap, field) ; GB_Global.is_csc = (va_arg (ap, GxB_Format_Value) != GxB_BY_ROW) ; va_end (ap) ; break ; default : return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG, "invalid option field [%d], must be one of:\n" "GxB_HYPER [%d] or GxB_FORMAT [%d]", (int) field, (int) GxB_HYPER, (int) GxB_FORMAT))) ; } return (GrB_SUCCESS) ; }
GrB_Info GrB_Matrix_assign // C<Mask>(Rows,Cols) += A or A' ( GrB_Matrix C, // input/output matrix for results const GrB_Matrix Mask, // mask for C, unused if NULL const GrB_BinaryOp accum, // accum for Z=accum(C(Rows,Cols),T) const GrB_Matrix A, // first input: matrix A const GrB_Index *Rows, // row indices GrB_Index nRows, // number of row indices const GrB_Index *Cols, // column indices GrB_Index nCols, // number of column indices const GrB_Descriptor desc // descriptor for C, Mask, and A ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GrB_Matrix_assign" " (C, Mask, accum, A, Rows, nRows, Cols, nCols, desc)") ; GB_RETURN_IF_NULL_OR_FAULTY (C) ; GB_RETURN_IF_FAULTY (Mask) ; GB_RETURN_IF_NULL_OR_FAULTY (A) ; // get the descriptor GB_GET_DESCRIPTOR (info, desc, C_replace, Mask_comp, A_transpose, xx1, xx2); //-------------------------------------------------------------------------- // C<Mask>(Rows,Cols) = accum (C(Rows,Cols), A) and variations //-------------------------------------------------------------------------- return (GB_assign ( C, C_replace, // C matrix and its descriptor Mask, Mask_comp, // Mask matrix and its descriptor false, // do not transpose the mask accum, // for accum (C(Rows,Cols),A) A, A_transpose, // A and its descriptor (T=A or A') Rows, nRows, // row indices Cols, nCols, // column indices false, NULL, 0, // no scalar expansion false, false, // not GrB_Col_assign nor GrB_row_assign Context)) ; }
GrB_Info GxB_Vector_type // get the type of a vector ( GrB_Type *type, // returns the type of the vector const GrB_Vector v // vector to query ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GxB_Vector_type (&type, v)") ; GB_RETURN_IF_NULL_OR_FAULTY (v) ; //-------------------------------------------------------------------------- // get the type //-------------------------------------------------------------------------- return (GB_type (type, (GrB_Matrix) v, Context)) ; }
GrB_Info GxB_Monoid_fprint // print and check a GrB_Monoid ( GrB_Monoid monoid, // object to print and check const char *name, // name of the object GxB_Print_Level pr, // print level FILE *f // file for output ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GxB_Monoid_fprint (monoid, name, pr, f)") ; //-------------------------------------------------------------------------- // print and check the object //-------------------------------------------------------------------------- return (GB_Monoid_check (monoid, name, pr, f, Context)) ; }
GrB_Info GrB_Vector_nvals // get the number of entries in a vector ( GrB_Index *nvals, // number of entries const GrB_Vector v // vector to query ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GrB_Vector_nvals (&nvals, v)") ; GB_RETURN_IF_NULL_OR_FAULTY (v) ; ASSERT (GB_VECTOR_OK (v)) ; // do not check if nvals is NULL; pending updates must be applied first, in // GB_nvals, per Table 2.4 in the spec //-------------------------------------------------------------------------- // get the number of entries //-------------------------------------------------------------------------- return (GB_nvals (nvals, (GrB_Matrix) v, Context)) ; }
GrB_Info GxB_Matrix_Option_get // gets the current option of a matrix ( GrB_Matrix A, // matrix to query GxB_Option_Field field, // option to query ... // return value of the matrix option ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GxB_Matrix_Option_get (A, field, &value)") ; GB_RETURN_IF_NULL_OR_FAULTY (A) ; ASSERT_OK (GB_check (A, "A to get option", GB0)) ; //-------------------------------------------------------------------------- // get the option //-------------------------------------------------------------------------- va_list ap ; double *hyper_ratio, hyper ; GxB_Format_Value *format ; bool is_csc ; hyper = A->hyper_ratio ; is_csc = A->is_csc ; switch (field) { case GxB_HYPER : va_start (ap, field) ; hyper_ratio = va_arg (ap, double *) ; va_end (ap) ; GB_RETURN_IF_NULL (hyper_ratio) ; (*hyper_ratio) = hyper ; break ; case GxB_FORMAT : va_start (ap, field) ; format = va_arg (ap, GxB_Format_Value *) ; va_end (ap) ; GB_RETURN_IF_NULL (format) ; (*format) = (is_csc) ? GxB_BY_COL : GxB_BY_ROW ; break ; default : return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG, "invalid option field [%d], must be one of:\n" "GxB_HYPER [%d] or GxB_FORMAT [%d]", (int) field, (int) GxB_HYPER, (int) GxB_FORMAT))) ; } return (GrB_SUCCESS) ; }
GrB_Info GB_Type_new ( GrB_Type *type, // handle of user type to create const size_t sizeof_ctype, // size of the user type const char *name // name of the type, as "sizeof (ctype)" ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GrB_Type_new (&type, sizeof (ctype))") ; GB_RETURN_IF_NULL (type) ; (*type) = NULL ; //-------------------------------------------------------------------------- // create the type //-------------------------------------------------------------------------- // allocate the type GB_CALLOC_MEMORY (*type, 1, sizeof (struct GB_Type_opaque)) ; if (*type == NULL) { return (GB_NO_MEMORY) ; } // initialize the type GrB_Type t = *type ; t->magic = GB_MAGIC ; t->size = GB_IMAX (sizeof_ctype, 1) ; t->code = GB_UDT_code ; // run-time user-defined type //-------------------------------------------------------------------------- // get the name //-------------------------------------------------------------------------- // if no name found, a generic name is used instead strncpy (t->name, "user-type", GB_LEN-1) ; char input2 [GB_LEN+1] ; char *p = NULL ; // look for "sizeof" in the input string if (name != NULL) { strncpy (input2, name, GB_LEN) ; p = strstr (input2, "sizeof") ; } if (p != NULL) { // "sizeof" appears in the input string, advance past it p += 6 ; // find leading "(" if it appears, and advance to one character past it char *p2 = strstr (p, "(") ; if (p2 != NULL) p = p2 + 1 ; // find trailing ")" if it appears, and delete it p2 = strstr (p, ")") ; if (p2 != NULL) *p2 = '\0' ; // p now contains the final name, copy it to the output name strncpy (t->name, p, GB_LEN-1) ; } return (GrB_SUCCESS) ; }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { bool malloc_debug = GB_mx_get_global (true) ; GrB_Matrix A = NULL ; void *Y = NULL ; void *Xtemp = NULL ; void *X = NULL ; GrB_Index nvals = 0 ; // check inputs GB_WHERE (USAGE) ; if (nargout > 3 || nargin < 1 || nargin > 2) { mexErrMsgTxt ("Usage: " USAGE) ; } #define GET_DEEP_COPY ; #define FREE_DEEP_COPY ; // get A (shallow copy) A = GB_mx_mxArray_to_Matrix (pargin [0], "A input", false, true) ; if (A == NULL) { FREE_ALL ; mexErrMsgTxt ("A failed") ; } mxClassID aclass = GB_mx_Type_to_classID (A->type) ; // get the number of entries in A GrB_Matrix_nvals (&nvals, A) ; mxClassID xclass ; GrB_Type xtype ; if (A->type == Complex) { // input argument xclass is ignored xtype = Complex ; xclass = mxDOUBLE_CLASS ; // create Xtemp if (nargout > 2) { GB_MALLOC_MEMORY (Xtemp, nvals, sizeof (double complex)) ; } } else { // get xclass, default is class (A), and the corresponding xtype xclass = GB_mx_string_to_classID (aclass, PARGIN (1)) ; xtype = GB_mx_classID_to_Type (xclass) ; if (xtype == NULL) { FREE_ALL ; mexErrMsgTxt ("X must be numeric") ; } // create X if (nargout > 2) { pargout [2] = mxCreateNumericMatrix (nvals, 1, xclass, mxREAL) ; X = (void *) mxGetData (pargout [2]) ; } } // create I pargout [0] = mxCreateNumericMatrix (nvals, 1, mxUINT64_CLASS, mxREAL) ; GrB_Index *I = (GrB_Index *) mxGetData (pargout [0]) ; // create J GrB_Index *J = NULL ; if (nargout > 1) { pargout [1] = mxCreateNumericMatrix (nvals, 1, mxUINT64_CLASS, mxREAL) ; J = (GrB_Index *) mxGetData (pargout [1]) ; } // [I,J,X] = find (A) if (GB_VECTOR_OK (A)) { // test extract vector methods GrB_Vector v = (GrB_Vector) A ; switch (xtype->code) { case GB_BOOL_code : METHOD (GrB_Vector_extractTuples (I, (bool *) X, &nvals, v)) ; break ; case GB_INT8_code : METHOD (GrB_Vector_extractTuples (I, (int8_t *) X, &nvals, v)) ; break ; case GB_UINT8_code : METHOD (GrB_Vector_extractTuples (I, (uint8_t *) X, &nvals, v)) ; break ; case GB_INT16_code : METHOD (GrB_Vector_extractTuples (I, (int16_t *) X, &nvals, v)) ; break ; case GB_UINT16_code : METHOD (GrB_Vector_extractTuples (I, (uint16_t *) X, &nvals, v)) ; break ; case GB_INT32_code : METHOD (GrB_Vector_extractTuples (I, (int32_t *) X, &nvals, v)) ; break ; case GB_UINT32_code : METHOD (GrB_Vector_extractTuples (I, (uint32_t *) X, &nvals, v)) ; break ; case GB_INT64_code : METHOD (GrB_Vector_extractTuples (I, (int64_t *) X, &nvals, v)) ; break ; case GB_UINT64_code : METHOD (GrB_Vector_extractTuples (I, (uint64_t *) X, &nvals, v)) ; break ; case GB_FP32_code : METHOD (GrB_Vector_extractTuples (I, (float *) X, &nvals, v)) ; break ; case GB_FP64_code : METHOD (GrB_Vector_extractTuples (I, (double *) X, &nvals, v)) ; break ; case GB_UCT_code : case GB_UDT_code : METHOD (GrB_Vector_extractTuples (I, Xtemp, &nvals, v)) ; break ; default : FREE_ALL ; mexErrMsgTxt ("unsupported class") ; } if (J != NULL) { for (int64_t p = 0 ; p < nvals ; p++) J [p] = 0 ; } } else { switch (xtype->code) { case GB_BOOL_code : METHOD (GrB_Matrix_extractTuples (I, J, (bool *) X, &nvals, A)) ; break ; case GB_INT8_code : METHOD (GrB_Matrix_extractTuples (I, J, (int8_t *) X, &nvals, A)) ; break ; case GB_UINT8_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint8_t *) X, &nvals, A)) ; break ; case GB_INT16_code : METHOD (GrB_Matrix_extractTuples (I, J, (int16_t *) X, &nvals, A)) ; break ; case GB_UINT16_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint16_t *) X, &nvals, A)) ; break ; case GB_INT32_code : METHOD (GrB_Matrix_extractTuples (I, J, (int32_t *) X, &nvals, A)) ; break ; case GB_UINT32_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint32_t *) X, &nvals, A)) ; break ; case GB_INT64_code : METHOD (GrB_Matrix_extractTuples (I, J, (int64_t *) X, &nvals, A)) ; break ; case GB_UINT64_code : METHOD (GrB_Matrix_extractTuples (I, J, (uint64_t *) X, &nvals, A)) ; break ; case GB_FP32_code : METHOD (GrB_Matrix_extractTuples (I, J, (float *) X, &nvals, A)) ; break ; case GB_FP64_code : METHOD (GrB_Matrix_extractTuples (I, J, (double *) X, &nvals, A)) ; break; case GB_UCT_code : case GB_UDT_code : METHOD (GrB_Matrix_extractTuples (I, J, Xtemp, &nvals, A)) ; break; default : FREE_ALL ; mexErrMsgTxt ("unsupported class") ; } } if (A->type == Complex && nargout > 2) { // create the MATLAB complex X pargout [2] = mxCreateNumericMatrix (nvals, 1, mxDOUBLE_CLASS, mxCOMPLEX) ; GB_mx_complex_split (nvals, Xtemp, pargout [2]) ; } FREE_ALL ; }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { bool malloc_debug = GB_mx_get_global (true) ; GrB_Matrix C = NULL ; GrB_Descriptor desc = NULL ; GrB_Index *I = NULL, ni = 0, I_range [3] ; GrB_Index *J = NULL, nj = 0, J_range [3] ; bool ignore ; // check inputs GB_WHERE (USAGE) ; if (nargout > 1 || nargin < 2 || nargin > 5) { mexErrMsgTxt ("Usage: " USAGE) ; } // get C (make a deep copy) #define GET_DEEP_COPY \ C = GB_mx_mxArray_to_Matrix (pargin [0], "C input", true, true) ; #define FREE_DEEP_COPY GB_MATRIX_FREE (&C) ; GET_DEEP_COPY ; if (C == NULL) { FREE_ALL ; mexErrMsgTxt ("C failed") ; } mxClassID cclass = GB_mx_Type_to_classID (C->type) ; // get accum; default: NOP, default class is class(C) GrB_BinaryOp accum ; if (!GB_mx_mxArray_to_BinaryOp (&accum, pargin [1], "accum", GB_NOP_opcode, cclass, C->type == Complex, C->type == Complex)) { FREE_ALL ; mexErrMsgTxt ("accum failed") ; } // get I if (!GB_mx_mxArray_to_indices (&I, PARGIN (2), &ni, I_range, &ignore)) { FREE_ALL ; mexErrMsgTxt ("I failed") ; } // get J if (!GB_mx_mxArray_to_indices (&J, PARGIN (3), &nj, J_range, &ignore)) { FREE_ALL ; mexErrMsgTxt ("J failed") ; } // get desc if (!GB_mx_mxArray_to_Descriptor (&desc, PARGIN (4), "desc")) { FREE_ALL ; mexErrMsgTxt ("desc failed") ; } GrB_Index nrows, ncols ; GrB_Matrix_nvals (&nrows, C) ; GrB_Matrix_nvals (&ncols, C) ; // C(I,J) = accum (C(I,J),C) METHOD (GrB_assign (C, NULL, accum, C, I, ni, J, nj, desc)) ; GrB_wait ( ) ; TOC ; // return C to MATLAB as a struct and free the GraphBLAS C pargout [0] = GB_mx_Matrix_to_mxArray (&C, "C output", true) ; FREE_ALL ; }
void mexFunction ( int nargout, mxArray *pargout [ ], int nargin, const mxArray *pargin [ ] ) { bool malloc_debug = GB_mx_get_global (true) ; GrB_Matrix C = NULL ; GrB_Matrix Mask = NULL ; GrB_Matrix A = NULL ; GrB_Descriptor desc = NULL ; GrB_Index *I = NULL, ni = 0, I_range [3] ; GrB_Index *J = NULL, nj = 0, J_range [3] ; bool ignore ; GB_WHERE (USAGE) ; // check inputs if (nargout > 1 || nargin < 6 || nargin > 7) { mexErrMsgTxt ("Usage: " USAGE) ; } // get C (make a deep copy) #define GET_DEEP_COPY \ C = GB_mx_mxArray_to_Matrix (pargin [0], "C input", true, true) ; #define FREE_DEEP_COPY GB_MATRIX_FREE (&C) ; GET_DEEP_COPY ; if (C == NULL) { FREE_ALL ; mexErrMsgTxt ("C failed") ; } mxClassID cclass = GB_mx_Type_to_classID (C->type) ; // get Mask (shallow copy) Mask = GB_mx_mxArray_to_Matrix (pargin [1], "Mask", false, false) ; if (Mask == NULL && !mxIsEmpty (pargin [1])) { FREE_ALL ; mexErrMsgTxt ("Mask failed") ; } // get A (shallow copy) A = GB_mx_mxArray_to_Matrix (pargin [3], "A input", false, true) ; if (A == NULL) { FREE_ALL ; mexErrMsgTxt ("A failed") ; } // get accum; default: NOP, default class is class(C) GrB_BinaryOp accum ; if (!GB_mx_mxArray_to_BinaryOp (&accum, pargin [2], "accum", GB_NOP_opcode, cclass, C->type == Complex, A->type == Complex)) { FREE_ALL ; mexErrMsgTxt ("accum failed") ; } // get I if (!GB_mx_mxArray_to_indices (&I, pargin [4], &ni, I_range, &ignore)) { FREE_ALL ; mexErrMsgTxt ("I failed") ; } // get J if (!GB_mx_mxArray_to_indices (&J, pargin [5], &nj, J_range, &ignore)) { FREE_ALL ; mexErrMsgTxt ("J failed") ; } // get desc if (!GB_mx_mxArray_to_Descriptor (&desc, PARGIN (6), "desc")) { FREE_ALL ; mexErrMsgTxt ("desc failed") ; } // C<Mask> = accum (C,A(I,J)) METHOD (GrB_extract (C, Mask, accum, A, I, ni, J, nj, desc)) ; // return C to MATLAB as a struct and free the GraphBLAS C pargout [0] = GB_mx_Matrix_to_mxArray (&C, "C output", true) ; FREE_ALL ; }
GrB_Info GxB_Global_Option_get // gets the current global option ( GxB_Option_Field field, // option to query ... // return value of the global option ) { //-------------------------------------------------------------------------- // check inputs //-------------------------------------------------------------------------- GB_WHERE ("GxB_Global_Option_get (field, &value)") ; //-------------------------------------------------------------------------- // get the option //-------------------------------------------------------------------------- va_list ap ; switch (field) { //---------------------------------------------------------------------- // hyper_ratio //---------------------------------------------------------------------- case GxB_HYPER : va_start (ap, field) ; double *hyper_ratio = va_arg (ap, double *) ; va_end (ap) ; GB_RETURN_IF_NULL (hyper_ratio) ; (*hyper_ratio) = GB_Global.hyper_ratio ; break ; //---------------------------------------------------------------------- // matrix format (CSR or CSC) //---------------------------------------------------------------------- case GxB_FORMAT : va_start (ap, field) ; GxB_Format_Value *format = va_arg (ap, GxB_Format_Value *) ; va_end (ap) ; GB_RETURN_IF_NULL (format) ; (*format) = (GB_Global.is_csc) ? GxB_BY_COL : GxB_BY_ROW ; break ; //---------------------------------------------------------------------- // mode from GrB_init (blocking or non-blocking) //---------------------------------------------------------------------- case GxB_MODE : va_start (ap, field) ; GrB_Mode *mode = va_arg (ap, GrB_Mode *) ; va_end (ap) ; GB_RETURN_IF_NULL (mode) ; (*mode) = GB_Global.mode ; break ; //---------------------------------------------------------------------- // threading model for synchronizing user threads //---------------------------------------------------------------------- case GxB_THREAD_SAFETY : va_start (ap, field) ; GxB_Thread_Model *thread_safety = va_arg (ap, GxB_Thread_Model *) ; va_end (ap) ; GB_RETURN_IF_NULL (thread_safety) ; (*thread_safety) = #if defined (USER_POSIX_THREADS) GxB_THREAD_POSIX ; #elif defined (USER_WINDOWS_THREADS) GxB_THREAD_WINDOWS ; // Windows threads not yet supported #elif defined (USER_ANSI_THREADS) GxB_THREAD_ANSI ; // ANSI C11 threads not yet supported #elif defined (_OPENMP) || defined (USER_OPENMP_THREADS) GxB_THREAD_OPENMP ; #else GxB_THREAD_NONE ; // GraphBLAS is not thread safe! #endif break ; //---------------------------------------------------------------------- // internal parallel threading in GraphBLAS (currently none) //---------------------------------------------------------------------- case GxB_THREADING : va_start (ap, field) ; GxB_Thread_Model *threading = va_arg (ap, GxB_Thread_Model *) ; va_end (ap) ; GB_RETURN_IF_NULL (threading) ; (*threading) = GxB_THREAD_NONE ; break ; //---------------------------------------------------------------------- // invalid option //---------------------------------------------------------------------- default : return (GB_ERROR (GrB_INVALID_VALUE, (GB_LOG, "invalid option field [%d], must be one of:\n" "GxB_HYPER [%d], GxB_FORMAT [%d], GxB_MODE [%d]," "GxB_THREAD_SAFETY [%d], or GxB_THREADING [%d]", (int) field, (int) GxB_HYPER, (int) GxB_FORMAT, (int) GxB_MODE, (int) GxB_THREAD_SAFETY, (int) GxB_THREADING))) ; } return (GrB_SUCCESS) ; }