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) ;
}
