rename user-defined ops inside LAGraph (guard against future name collisions)

Author: DrTimothyAldenDavis

experimental/algorithm/LAGr_EdgeBetweennessCentrality.c

@@ -66,15 +66,15 @@
 // (1+x)/y function for double: z = (1 + x) / y
 //------------------------------------------------------------------------------
 
-void add_one_divide_function (double *z, const double *x, const double *y)
+void LG_EBC_add_one_divide_function (double *z, const double *x, const double *y)
 {
     double a = (*(x)) ;
     double b = (*(y)) ;
     (*(z)) = (1 + a) / b ;
 }
 
 #define ADD_ONE_DIVIDE_FUNCTION_DEFN                                           \
-"void add_one_divide_function (double *z, const double *x, const double *y)\n" \
+"void LG_EBC_add_one_divide_function (double *z, const double *x, const double *y)\n" \
 "{                                                                         \n" \
 "    double a = (*(x)) ;                                                   \n" \
 "    double b = (*(y)) ;                                                   \n" \
@@ -203,9 +203,9 @@ int LAGr_EdgeBetweennessCentrality
     // =========================================================================
 
     GRB_TRY (GxB_BinaryOp_new (&Add_One_Divide,
-        (GxB_binary_function) add_one_divide_function,
+        (GxB_binary_function) LG_EBC_add_one_divide_function,
         GrB_FP64, GrB_FP64, GrB_FP64,
-        "add_one_divide_function", ADD_ONE_DIVIDE_FUNCTION_DEFN)) ;
+        "LG_EBC_add_one_divide_function", ADD_ONE_DIVIDE_FUNCTION_DEFN)) ;
 
     // Initialize the frontier, paths, Update, and bc_vertex_flow
     GRB_TRY (GrB_Vector_new (&paths,    GrB_FP64, n)) ;

experimental/algorithm/LAGr_MaxFlow.c

@@ -46,114 +46,114 @@ typedef struct
 {
     uint64_t parentC;
     uint64_t rootC;
-} vertex;
+} LG_MM_vertex;
 
 // repeat the typedef as a string, to give to GraphBLAS
 #define VERTEX_DEFN         \
 "typedef struct         \n" \
 "{                      \n" \
 "    uint64_t parentC;  \n" \
 "    uint64_t rootC;    \n" \
-"} vertex;"
+"} LG_MM_vertex;"
 
-void initFrontier(vertex *z, const bool *x, uint64_t i, uint64_t j, const bool *y)
+void LG_MM_initFrontier(LG_MM_vertex *z, const bool *x, uint64_t i, uint64_t j, const bool *y)
 {
     z->parentC = i;
     z->rootC = i;
 }
 
 #define INIT_FRONTIER_DEFN  \
-"void initFrontier(vertex *z, const bool *x, uint64_t i, uint64_t j, const bool *y) \n" \
+"void LG_MM_initFrontier(LG_MM_vertex *z, const bool *x, uint64_t i, uint64_t j, const bool *y) \n" \
 "{                      \n" \
 "    z->parentC = i;    \n" \
 "    z->rootC = i;      \n" \
 "}"
 
-void minparent(vertex *z, const vertex *x, const vertex *y)
+void LG_MM_minparent(LG_MM_vertex *z, const LG_MM_vertex *x, const LG_MM_vertex *y)
 {
     *z = x->parentC < y->parentC ? *x : *y;
 }
 
 #define MIN_PARENT_DEFN                                             \
-"void minparent(vertex *z, const vertex *x, const vertex *y)    \n" \
+"void LG_MM_minparent(LG_MM_vertex *z, const LG_MM_vertex *x, const LG_MM_vertex *y)    \n" \
 "{                                                              \n" \
 "    *z = x->parentC < y->parentC ? *x : *y;                    \n" \
 "}"
 
-// TODO: revise GraphBLAS so we can tell it that the select2nd operator
+// TODO: revise GraphBLAS so we can tell it that the LG_MM_select2nd operator
 // does not use the 'x' input.
-void select2nd(vertex *z, const bool *x, const vertex *y)
+void LG_MM_select2nd(LG_MM_vertex *z, const bool *x, const LG_MM_vertex *y)
 {
     z->parentC = y->parentC;
     z->rootC = y->rootC;
 }
 
 #define SELECT_2ND_DEFN                                             \
-"void select2nd(vertex *z, const bool *x, const vertex *y)      \n" \
+"void LG_MM_select2nd(LG_MM_vertex *z, const bool *x, const LG_MM_vertex *y)      \n" \
 "{                                                              \n" \
 "    z->parentC = y->parentC;                                   \n" \
 "    z->rootC = y->rootC;                                       \n" \
 "}"
 
-void select1st(vertex *z, const vertex *x, const bool *y)
+void LG_MM_select1st(LG_MM_vertex *z, const LG_MM_vertex *x, const bool *y)
 {
     z->parentC = x->parentC;
     z->rootC = x->rootC;
 }
 
 #define SELECT_1ST_DEFN                                             \
-"void select1st(vertex *z, const vertex *x, const bool *y)      \n" \
+"void LG_MM_select1st(LG_MM_vertex *z, const LG_MM_vertex *x, const bool *y)      \n" \
 "{                                                              \n" \
 "    z->parentC = x->parentC;                                   \n" \
 "    z->rootC = x->rootC;                                       \n" \
 "}"
 
-void keepParents(uint64_t *z, const vertex *x) { *z = x->parentC; }
+void LG_MM_keepParents(uint64_t *z, const LG_MM_vertex *x) { *z = x->parentC; }
 
 #define KEEP_PARENTS_DEFN                                           \
-"void keepParents(uint64_t *z, const vertex *x) { *z = x->parentC; }\n"
+"void LG_MM_keepParents(uint64_t *z, const LG_MM_vertex *x) { *z = x->parentC; }\n"
 
-void keepRoots(uint64_t *z, const vertex *x) { *z = x->rootC; }
+void LG_MM_keepRoots(uint64_t *z, const LG_MM_vertex *x) { *z = x->rootC; }
 
 #define KEEP_ROOTS_DEFN                                                        \
-"void keepRoots(uint64_t *z, const vertex *x) { *z = x->rootC; }\n"
+"void LG_MM_keepRoots(uint64_t *z, const LG_MM_vertex *x) { *z = x->rootC; }\n"
 
-void buildfCTuples(vertex *z, const uint64_t *x, uint64_t i, uint64_t j,
+void LG_MM_buildfCTuples(LG_MM_vertex *z, const uint64_t *x, uint64_t i, uint64_t j,
                    const bool *y)
 {
     z->parentC = i;
     z->rootC = *x;
 }
 
 #define BUILT_FC_TUPLES_DEFN                                        \
-"void buildfCTuples(vertex *z, const uint64_t *x, uint64_t i, uint64_t j,   \n" \
+"void LG_MM_buildfCTuples(LG_MM_vertex *z, const uint64_t *x, uint64_t i, uint64_t j,   \n" \
 "                   const bool *y)                              \n" \
 "{                                                              \n" \
 "    z->parentC = i;                                            \n" \
 "    z->rootC = *x;                                             \n" \
 "}"
 
-void vertexTypecast(vertex *z, const uint64_t *x)
+void LG_MM_vertexTypecast(LG_MM_vertex *z, const uint64_t *x)
 {
     z->parentC = *x;
     z->rootC = *x;
 }
 
 #define VERTEX_TYPECAST_DEFN                                        \
-"void vertexTypecast(vertex *z, const uint64_t *x)              \n" \
+"void LG_MM_vertexTypecast(LG_MM_vertex *z, const uint64_t *x)              \n" \
 "{                                                              \n" \
 "    z->parentC = *x;                                           \n" \
 "    z->rootC = *x;                                             \n" \
 "}"
 
-void setParentsMates(vertex *z, const vertex *x, const vertex *y)
+void LG_MM_setParentsMates(LG_MM_vertex *z, const LG_MM_vertex *x, const LG_MM_vertex *y)
 {
     z->parentC = y->parentC;
     z->rootC = x->rootC;
 }
 
 #define SET_PARENTS_MATES_DEFN                                          \
-"void setParentsMates(vertex *z, const vertex *x, const vertex *y)  \n" \
+"void LG_MM_setParentsMates(LG_MM_vertex *z, const LG_MM_vertex *x, const LG_MM_vertex *y)  \n" \
 "{                                                                  \n" \
 "    z->parentC = y->parentC;                                       \n" \
 "    z->rootC = x->rootC;                                           \n" \
@@ -397,8 +397,8 @@ invert_2(GrB_Vector out,  // input/output
     GRB_TRY(GrB_Vector_wait(in1, GrB_MATERIALIZE));
     if (udt)
     {
-        vertex *X1_V = NULL;
-        LG_TRY(LAGraph_Malloc((void **)&X1_V, nvals2, sizeof(vertex), msg));
+        LG_MM_vertex *X1_V = NULL;
+        LG_TRY(LAGraph_Malloc((void **)&X1_V, nvals2, sizeof(LG_MM_vertex), msg));
         for (uint64_t i = 0; i < nvals2; i++)
         {
             GRB_TRY(GrB_Vector_extractElement_UDT(
@@ -570,73 +570,73 @@ int LAGr_MaximumMatching(
     GRB_TRY(GrB_Vector_new(&parentsR, GrB_UINT64, nrows));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_Type_new(&Vertex, sizeof(vertex), "vertex", VERTEX_DEFN));
+    GRB_TRY(GxB_Type_new(&Vertex, sizeof(LG_MM_vertex), "LG_MM_vertex", VERTEX_DEFN));
 #else
-    GRB_TRY(GrB_Type_new(&Vertex, sizeof(vertex)));
+    GRB_TRY(GrB_Type_new(&Vertex, sizeof(LG_MM_vertex)));
 #endif
 
     GRB_TRY(GrB_Vector_new(&frontierC, Vertex, ncols));
 
     GRB_TRY(GrB_Vector_new(&frontierR, Vertex, nrows));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_IndexUnaryOp_new(&initFrontierOp, (void *)initFrontier, Vertex,
-                                 GrB_BOOL, GrB_BOOL, "initFrontier",
+    GRB_TRY(GxB_IndexUnaryOp_new(&initFrontierOp, (void *)LG_MM_initFrontier, Vertex,
+                                 GrB_BOOL, GrB_BOOL, "LG_MM_initFrontier",
                                  INIT_FRONTIER_DEFN));
 #else
-    GRB_TRY(GrB_IndexUnaryOp_new(&initFrontierOp, (void *)initFrontier, Vertex,
+    GRB_TRY(GrB_IndexUnaryOp_new(&initFrontierOp, (void *)LG_MM_initFrontier, Vertex,
                                  GrB_BOOL, GrB_BOOL));
 #endif
 
     GRB_TRY(GrB_Vector_new(&I, GrB_BOOL, ncols));
     GRB_TRY(GrB_Vector_assign_BOOL(I, NULL, NULL, 1, GrB_ALL, ncols, NULL));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_BinaryOp_new(&MinParent, (void *)minparent, Vertex, Vertex,
-                             Vertex, "minparent", MIN_PARENT_DEFN));
+    GRB_TRY(GxB_BinaryOp_new(&MinParent, (void *)LG_MM_minparent, Vertex, Vertex,
+                             Vertex, "LG_MM_minparent", MIN_PARENT_DEFN));
 #else
-    GRB_TRY(GrB_BinaryOp_new(&MinParent, (void *)minparent, Vertex, Vertex,
+    GRB_TRY(GrB_BinaryOp_new(&MinParent, (void *)LG_MM_minparent, Vertex, Vertex,
                              Vertex));
 #endif
-    vertex infinityParent = {GrB_INDEX_MAX + 1, 0};
+    LG_MM_vertex infinityParent = {GrB_INDEX_MAX + 1, 0};
     GRB_TRY(GrB_Monoid_new_UDT(&MinParent_Monoid, MinParent, &infinityParent));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_BinaryOp_new(&Select2ndOp, (void *)select2nd, Vertex, GrB_BOOL,
-                             Vertex, "select2nd", SELECT_2ND_DEFN));
+    GRB_TRY(GxB_BinaryOp_new(&Select2ndOp, (void *)LG_MM_select2nd, Vertex, GrB_BOOL,
+                             Vertex, "LG_MM_select2nd", SELECT_2ND_DEFN));
 #else
-    GRB_TRY(GrB_BinaryOp_new(&Select2ndOp, (void *)select2nd, Vertex, GrB_BOOL,
+    GRB_TRY(GrB_BinaryOp_new(&Select2ndOp, (void *)LG_MM_select2nd, Vertex, GrB_BOOL,
                              Vertex));
 #endif
 
     GRB_TRY(GrB_Semiring_new(&MinParent_2nd_Semiring, MinParent_Monoid,
                              Select2ndOp));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_BinaryOp_new(&Select1stOp, (void *)select1st, Vertex, Vertex,
-                             GrB_BOOL, "select1st", SELECT_1ST_DEFN));
+    GRB_TRY(GxB_BinaryOp_new(&Select1stOp, (void *)LG_MM_select1st, Vertex, Vertex,
+                             GrB_BOOL, "LG_MM_select1st", SELECT_1ST_DEFN));
 #else
-    GRB_TRY(GrB_BinaryOp_new(&Select1stOp, (void *)select1st, Vertex, Vertex,
+    GRB_TRY(GrB_BinaryOp_new(&Select1stOp, (void *)LG_MM_select1st, Vertex, Vertex,
                              GrB_BOOL));
 #endif
 
     GRB_TRY(GrB_Semiring_new(&MinParent_1st_Semiring, MinParent_Monoid,
                              Select1stOp));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_UnaryOp_new(&getParentsOp, (void *)keepParents, GrB_UINT64,
-                            Vertex, "keepParents", KEEP_PARENTS_DEFN));
+    GRB_TRY(GxB_UnaryOp_new(&getParentsOp, (void *)LG_MM_keepParents, GrB_UINT64,
+                            Vertex, "LG_MM_keepParents", KEEP_PARENTS_DEFN));
 #else
-    GRB_TRY(GrB_UnaryOp_new(&getParentsOp, (void *)keepParents, GrB_UINT64,
+    GRB_TRY(GrB_UnaryOp_new(&getParentsOp, (void *)LG_MM_keepParents, GrB_UINT64,
                             Vertex));
 #endif
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_UnaryOp_new(&getRootsOp, (void *)keepRoots, GrB_UINT64, Vertex,
-                            "keepRoots", KEEP_ROOTS_DEFN));
+    GRB_TRY(GxB_UnaryOp_new(&getRootsOp, (void *)LG_MM_keepRoots, GrB_UINT64, Vertex,
+                            "LG_MM_keepRoots", KEEP_ROOTS_DEFN));
 #else
     GRB_TRY(
-        GrB_UnaryOp_new(&getRootsOp, (void *)keepRoots, GrB_UINT64, Vertex));
+        GrB_UnaryOp_new(&getRootsOp, (void *)LG_MM_keepRoots, GrB_UINT64, Vertex));
 #endif
 
     GRB_TRY(GrB_Vector_new(&parentsUpdate, GrB_UINT64, nrows));
@@ -654,29 +654,29 @@ int LAGr_MaximumMatching(
     GRB_TRY(GrB_Vector_new(&rootfRIndexes, GrB_UINT64, ncols));
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_IndexUnaryOp_new(&buildfCTuplesOp, (void *)buildfCTuples,
-                                 Vertex, GrB_UINT64, GrB_BOOL, "buildfCTuples",
+    GRB_TRY(GxB_IndexUnaryOp_new(&buildfCTuplesOp, (void *)LG_MM_buildfCTuples,
+                                 Vertex, GrB_UINT64, GrB_BOOL, "LG_MM_buildfCTuples",
                                  BUILT_FC_TUPLES_DEFN));
 #else
-    GRB_TRY(GrB_IndexUnaryOp_new(&buildfCTuplesOp, (void *)buildfCTuples,
+    GRB_TRY(GrB_IndexUnaryOp_new(&buildfCTuplesOp, (void *)LG_MM_buildfCTuples,
                                  Vertex, GrB_UINT64, GrB_BOOL));
 #endif
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_UnaryOp_new(&vertexTypecastOp, (void *)vertexTypecast, Vertex,
-                            GrB_UINT64, "vertexTypecast",
+    GRB_TRY(GxB_UnaryOp_new(&vertexTypecastOp, (void *)LG_MM_vertexTypecast, Vertex,
+                            GrB_UINT64, "LG_MM_vertexTypecast",
                             VERTEX_TYPECAST_DEFN));
 #else
-    GRB_TRY(GrB_UnaryOp_new(&vertexTypecastOp, (void *)vertexTypecast, Vertex,
+    GRB_TRY(GrB_UnaryOp_new(&vertexTypecastOp, (void *)LG_MM_vertexTypecast, Vertex,
                             GrB_UINT64));
 #endif
 
 #if LAGRAPH_SUITESPARSE
-    GRB_TRY(GxB_BinaryOp_new(&setParentsMatesOp, (void *)setParentsMates,
-                             Vertex, Vertex, Vertex, "setParentsMates",
+    GRB_TRY(GxB_BinaryOp_new(&setParentsMatesOp, (void *)LG_MM_setParentsMates,
+                             Vertex, Vertex, Vertex, "LG_MM_setParentsMates",
                              SET_PARENTS_MATES_DEFN));
 #else
-    GRB_TRY(GrB_BinaryOp_new(&setParentsMatesOp, (void *)setParentsMates,
+    GRB_TRY(GrB_BinaryOp_new(&setParentsMatesOp, (void *)LG_MM_setParentsMates,
                              Vertex, Vertex, Vertex));
 #endif
 

experimental/algorithm/LAGr_MaximumMatching.c

@@ -88,7 +88,7 @@ This method requires O(n + e) space for an undirected graph with e edges and n n
 
 #if LAGRAPH_SUITESPARSE
 
-void valueeq_index_func (bool *z, const uint64_t *x, GrB_Index i, GrB_Index j, const void *y) {
+void LG_CM_valueeq_index_func (bool *z, const uint64_t *x, GrB_Index i, GrB_Index j, const void *y) {
     (*z) = ((*x) == i) ;
 }
 
@@ -162,7 +162,7 @@ static int LAGraph_Parent_to_S
                 - This fills in the new parents for discarded nodes
         */
 
-        GRB_TRY (GrB_IndexUnaryOp_new (&VALUEEQ_ROWINDEX_UINT64, F_INDEX_UNARY(valueeq_index_func), GrB_BOOL, GrB_UINT64, GrB_UINT64)) ;
+        GRB_TRY (GrB_IndexUnaryOp_new (&VALUEEQ_ROWINDEX_UINT64, F_INDEX_UNARY(LG_CM_valueeq_index_func), GrB_BOOL, GrB_UINT64, GrB_UINT64)) ;
 
         // identify preserved nodes
         GRB_TRY (GrB_select (parent_cpy, NULL, NULL, VALUEEQ_ROWINDEX_UINT64, parent, 0, NULL)) ;

experimental/algorithm/LAGraph_Coarsen_Matching.c

@@ -47,32 +47,32 @@
 #include "LG_internal.h"
 #include "LAGraphX.h"
 
-void mod32 (int32_t *z, const int32_t *x, const int32_t *y) ;
-void mod32 (int32_t *z, const int32_t *x, const int32_t *y)
+void LG_ED_mod32 (int32_t *z, const int32_t *x, const int32_t *y) ;
+void LG_ED_mod32 (int32_t *z, const int32_t *x, const int32_t *y)
 {
     /* make sure x is positive */
     int32_t t = ((*x) > 0) ? (*x) : -(*x) ;
     (*z) = t % (*y) ;
 }
 
 #define MOD32_DEFN                                                  \
-"void mod32 (int32_t *z, const int32_t *x, const int32_t *y)    \n" \
+"void LG_ED_mod32 (int32_t *z, const int32_t *x, const int32_t *y)    \n" \
 "{                                                              \n" \
 "    /* make sure x is positive */                              \n" \
 "    int32_t t = ((*x) > 0) ? (*x) : -(*x) ;                    \n" \
 "    (*z) = t % (*y) ;                                          \n" \
 "}"
 
-void mod64 (int64_t *z, const int64_t *x, const int64_t *y) ;
-void mod64 (int64_t *z, const int64_t *x, const int64_t *y)
+void LG_ED_mod64 (int64_t *z, const int64_t *x, const int64_t *y) ;
+void LG_ED_mod64 (int64_t *z, const int64_t *x, const int64_t *y)
 {
     /* make sure x is positive */
     int64_t t = ((*x) > 0) ? (*x) : -(*x) ;
     (*z) = t % (*y) ;
 }
 
 #define MOD64_DEFN                                                  \
-"void mod64 (int64_t *z, const int64_t *x, const int64_t *y)    \n" \
+"void LG_ED_mod64 (int64_t *z, const int64_t *x, const int64_t *y)    \n" \
 "{                                                              \n" \
 "    /* make sure x is positive */                              \n" \
 "    int64_t t = ((*x) > 0) ? (*x) : -(*x) ;                    \n" \
@@ -162,10 +162,10 @@ int LAGraph_EstimateDiameter
         // least one out-going edge.
         LAGRAPH_TRY (LAGraph_Random_Seed (srcs, seed, msg)) ;
         GRB_TRY (GxB_BinaryOp_new (&Mod,
-            (n > INT32_MAX) ? ((GxB_binary_function)mod64) :
-                              ((GxB_binary_function)mod32),
+            (n > INT32_MAX) ? ((GxB_binary_function)LG_ED_mod64) :
+                              ((GxB_binary_function)LG_ED_mod32),
             int_type, int_type, int_type,
-            (n > INT32_MAX) ? "mod64" : "mod32",
+            (n > INT32_MAX) ? "LG_ED_mod64" : "LG_ED_mod32",
             (n > INT32_MAX) ? MOD64_DEFN : MOD32_DEFN)) ;
         GRB_TRY (GrB_apply (srcs, NULL, NULL, Mod, srcs, n, NULL)) ;
         GrB_free (&Mod) ;

experimental/algorithm/LAGraph_EstimateDiameter.c

@@ -95,7 +95,7 @@
 #include "LG_internal.h"
 #include "LAGraphX.h"
 
-void sub_one_mult (int64_t *z, const int64_t *x) { (*z) = (*x) * ((*x)-1) ; }
+void LG_FGT_sub_one_mult (int64_t *z, const int64_t *x) { (*z) = (*x) * ((*x)-1) ; }
 
 int LAGraph_FastGraphletTransform
 (
@@ -208,7 +208,7 @@ int LAGraph_FastGraphletTransform
 
     GRB_TRY (GrB_Vector_new (&d_3, GrB_INT64, n)) ;
 
-    GRB_TRY (GrB_UnaryOp_new (&Sub_one_mult, F_UNARY (sub_one_mult), GrB_INT64, GrB_INT64)) ;
+    GRB_TRY (GrB_UnaryOp_new (&Sub_one_mult, F_UNARY (LG_FGT_sub_one_mult), GrB_INT64, GrB_INT64)) ;
 
     GRB_TRY (GrB_apply (d_3, NULL, NULL, Sub_one_mult, d_1, NULL)) ;
     GRB_TRY (GrB_apply (d_3, NULL, NULL, GrB_DIV_INT64, d_3, (int64_t) 2, NULL)) ;