changes

Author: Olumayowa-Olowomeye

experimental/algorithm/LAGraph_IsolateSets.c

@@ -17,7 +17,7 @@
     GrB_free(&Seed) ; \
     GrB_free(&degree) ; \
 }
-#define DEBUG 0
+#define DEBUG 1
 #define dbg(x) if (DEBUG) GxB_print(x,5)
 typedef GrB_Matrix mat;
 typedef GrB_Vector vec ;
@@ -49,7 +49,7 @@ int LAGraph_IsolateSets(
     GrB_Vector degree = NULL ;          // (float) G->out_degree
     GrB_Matrix A ;                      // G->A, the adjacency matrix
     GrB_Index n ;                       // # of nodes
-
+    printf("in Isolate set algorithm");
     LG_TRY (LAGraph_CheckGraph (G, msg)) ;
     LG_ASSERT(isolate_set != NULL, GrB_NULL_POINTER);
     A = G->A;
@@ -101,6 +101,7 @@ int LAGraph_IsolateSets(
     dbg(new_members);
     GRB_TRY (GrB_assign (iset, new_members, NULL,true,GrB_ALL,n,NULL)) ;
     (*isolate_set) = iset;
+    printf("done iset");
     iset = NULL;
     LG_FREE_ALL;
     return 0;

experimental/algorithm/LAGraph_Louvain.c

@@ -53,7 +53,7 @@ int LAGraph_Louvain(
 )
 {
     char MATRIX_TYPE[LAGRAPH_MSG_LEN];
-    GrB_set (GrB_GLOBAL, false, GxB_BURBLE);
+    GrB_set (GrB_GLOBAL, true, GxB_BURBLE);
     //assignment of monoids, bops, and semis   
     GrB_Monoid plusmon = GrB_PLUS_MONOID_FP64;
     GrB_Monoid maxmon = GrB_MAX_MONOID_FP64;
@@ -103,7 +103,7 @@ int LAGraph_Louvain(
     GRB_TRY(GrB_assign (x, NULL, NULL, 1, GrB_ALL, n, NULL)) ;
     // GxB_print(i,5);
     GRB_TRY(GrB_Matrix_diag(&S,x,0));
-    // GxB_print(S,5);
+    GxB_print(S,5);
 
     //var used in for loop
     GrB_Index vertices_changed;
@@ -137,6 +137,7 @@ int LAGraph_Louvain(
             // GxB_print(t_q,5);
 
             // sr = S(i,:)
+
             GRB_TRY(GrB_Col_extract(sr,NULL,NULL,S,GrB_ALL,1,i,GrB_DESC_T0));
             // GxB_print(sr,5);
 

experimental/algorithm/LAGraph_Louvain2.c

@@ -23,6 +23,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
+
 // #include <iostream>
 #undef LG_FREE_ALL
 #define LG_FREE_ALL                     \
@@ -53,7 +54,7 @@
         LAGraph_Free ((void *) &dSp, NULL) ;     \
         LAGraph_Free ((void *) &dSj, NULL) ;     \
     }
-#define DEBUG 1
+#define DEBUG 0
 #define dbg(x) if (DEBUG) GxB_print(x,5)
 // uint64_t seed = 213;
 typedef struct tuple_fp64{
@@ -69,13 +70,8 @@ void make_fp64(tuple_fp64 *z,
 {
     z->k = (int64_t)jx;
     z->v = (*x);
-    size_t tb = (*y)+1;
-    tb ^= tb << 13;
-    tb ^= tb >> 7;
-    tb ^= tb << 17;
-    tb = (tb ^ (tb >> 27)) * 0x94D049BB133111EB ;
-    tb = (tb ^ (tb >> 31)) ;
-    (tb = tb ^ (tb >> 30)) * 0xBF58476D1CE4E5B9 ;
+    uint64_t seed = (*y + ix + iy + jy);
+    uint64_t tb = LG_Random64(&seed);
     z->tb = tb;
 }
 void max_fp64(tuple_fp64 *z, const tuple_fp64 *x, const tuple_fp64 *y){
@@ -111,13 +107,8 @@ void max_fp64(tuple_fp64 *z, const tuple_fp64 *x, const tuple_fp64 *y){
 "{                                                           \n" \
 "    z->k = (int64_t)jx;                                     \n" \
 "    z->v = (*x);                   \n" \ 
-"     size_t tb = (*y)+1; \n"\
-"    tb ^= tb << 13;\n"\
-"    tb ^= tb >> 7;\n" \
-"    tb ^= tb << 17; \n"\
-"    tb = (tb ^ (tb >> 27)) * 0x94D049BB133111EB ; \n"\
-"    tb = (tb ^ (tb >> 31)) ;\n"\
-"  (tb = tb ^ (tb >> 30)) * 0xBF58476D1CE4E5B9 ;\n"\
+"    uint64_t seed = (*y + ix + iy + jy); \n"\
+"    uint64_t tb = LG_Random64(&seed);\n"\
 "    z->tb = tb;\n"\
 "}"
 
@@ -135,7 +126,7 @@ int LAGraph_Louvain2(
 
     char MATRIX_TYPE[LAGRAPH_MSG_LEN];
     if (DEBUG)
-        GrB_set (GrB_GLOBAL, false, GxB_BURBLE);
+        GrB_set (GrB_GLOBAL, true, GxB_BURBLE);
 
     //assignment of monoids, bops, and semis   
     GrB_Monoid plusmon = GrB_PLUS_MONOID_FP64;
@@ -184,12 +175,13 @@ int LAGraph_Louvain2(
     double o1;
     double k_i = 0;
     // FIXME: add check to see if S_result is NULL
-
+    LG_Random_Init(msg)
     LG_ASSERT(S_result != NULL, GrB_NULL_POINTER);
 
     GrB_Matrix A = G->A;
     // GxB_print(A,5);
-
+    // printf("rand init");
+    double test = 23;
 //index bin op definitions
 //------------------------------------------------------------------------------------------------------------------
 
@@ -207,7 +199,6 @@ int LAGraph_Louvain2(
     GRB_TRY(GrB_Semiring_new(&Semiring, Mon, Bop));
 //------------------------------------------------------------------------------------------------------------------
 
-    GRB_TRY(LAGraph_Random_Init(msg));
 
     GRB_TRY(GrB_Matrix_nrows(&n,A));
     GRB_TRY(GrB_Matrix_ncols(&b,A));
@@ -255,8 +246,8 @@ int LAGraph_Louvain2(
     bool changed = true;
     int max_iter = 20;
     int iter =0;
-    uint64_t seed = (uint64_t)time(NULL);
-    GRB_TRY(LAGraph_Random_Seed(y_rand,seed,msg));
+    uint64_t seed = 231;
+    
     // GxB_print(y_rand,5);
     GRB_TRY(GrB_mxv(z,NULL,NULL,stdmxm,S,k,NULL));
     // GxB_print(z,5);
@@ -309,7 +300,9 @@ int LAGraph_Louvain2(
             // GxB_print(q1,5);
             // printf("Size of q1: %ld\n",q1_size);
             // GRB_TRY(GrB_Vector_setElement_UINT64(y_rand,seed,0));
-            // GRB_TRY (GrB_assign (y_rand, t_q, NULL, seed, GrB_ALL, n, GrB_DESC_S));
+            seed+=i;
+            GRB_TRY (GrB_assign (y_rand, t_q, NULL, seed, GrB_ALL, n, GrB_DESC_S));
+
             // GxB_print(q1,5); 
             GRB_TRY(GrB_mxv(max_q1,NULL,NULL,Semiring,(GrB_Matrix)q1,y_rand,GrB_DESC_T0));
             // GxB_print(q1,5);

experimental/algorithm/LAGraph_LouvainMIS.c

@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
-#define DEBUG 0
+#define DEBUG 1
 #define dbg(x) if (DEBUG) GxB_print(x,5)
 #undef LG_FREE_ALL
 #define LG_FREE_ALL\
@@ -23,49 +23,70 @@ int LAGraph_LouvainMIS(
         GrB_set (GrB_GLOBAL, true, GxB_BURBLE);
     // Shortened monoids, Binary ops, and Semirings
     GrB_Monoid plusmon = GrB_PLUS_MONOID_FP64;
+    GrB_Monoid timesmon = GrB_TIMES_FP64;
     GrB_BinaryOp plusf64 = GrB_PLUS_FP64;
     GrB_BinaryOp timesf64 = GrB_TIMES_FP64;
     GrB_Semiring stdmxm = GrB_PLUS_TIMES_SEMIRING_FP64;
 
     // Declarations
     GrB_Vector iset = NULL;
+    GrB_Vector v = NULL;
     GrB_Vector k = NULL;
     GrB_Vector x = NULL;
+    GrB_Vector coef = NULL;
+    GrB_Vector z = NULL;
     GrB_Matrix S = NULL;
     GrB_Matrix A = NULL;
     GrB_Index n ; 
 
-
+    
     // Initializing 
     LG_TRY (LAGraph_CheckGraph (G, msg)) ;
     LG_ASSERT(S_result != NULL, GrB_NULL_POINTER);
+    
     A = G->A;
     dbg(A);
 
     //k = [+_j A(:,j)]
-    GRB_TRY(GrB_Vector_new(&iset,GrB_BOOL,n));
+    GRB_TRY(GrB_Matrix_nrows(&n,A));
     GRB_TRY(GrB_Vector_new(&k, GrB_FP64, n));
+    GRB_TRY(GrB_Vector_new(&coef,GrB_FP64,n));
+    GRB_TRY(GrB_Vector_new(&x,GrB_FP64,n));
+    GRB_TRY(GrB_Vector_new(&z,GrB_FP64,n));
+    GRB_TRY(GrB_Vector_new(&v,GrB_FP64,n));
+
+
     double m;
     GRB_TRY(GrB_Vector_reduce_FP64(&m,NULL,plusmon,k,NULL));
     m*=.5;
-
+    printf("%ld",m);
+    
     // S <- I
-    GRB_TRY(GrB_Vector_new(&x,GrB_FP64,n));
     GRB_TRY(GrB_assign (x, NULL, NULL, 1, GrB_ALL, n, NULL)) ;
     // GxB_print(i,5);
     GRB_TRY(GrB_Matrix_diag(&S,x,0));
-    
+    dbg(S);
     // Compute Isolate Set
-    
+    GRB_TRY(LAGraph_IsolateSets(&iset,G,123,msg));
+    dbg(iset);
 
     // Compute max change in modularity for each node in the isolate set
+    GRB_TRY(GrB_mxv(z,NULL,NULL,stdmxm,S,k,NULL));
+    dbg(z);
+    GRB_TRY (GrB_Matrix_reduce_Monoid(k, NULL, NULL,plusmon, A, NULL));
+    dbg(k);
+    GRB_TRY(GrB_Vector_eWiseMult_BinaryOp(coef,NULL,NULL,timesf64,k,iset,NULL));
+    
+    dbg(coef);
+
     // Aggregate Graph
     // Iterate till no change is detected
-    double Q;
-    double gamma = 1;
-    GRB_TRY(LAGr_Modularity2(&Q,gamma,A,S,msg));
-    // printf("Iterations: %d\n", iter);
-    printf("Q:%.15g\n",Q);
+    
+    // double Q;
+    // double gamma = 1;
+    // GRB_TRY(LAGr_Modularity2(&Q,gamma,A,S,msg));
+    // // printf("Iterations: %d\n", iter);
+    // printf("Q:%.15g\n",Q);
     (*S_result) = S ;
     S = NULL;
     LG_FREE_ALL;

experimental/algorithm/LaGr_Modularity2.c

@@ -119,7 +119,9 @@ int LAGr_Modularity2(
     //------------------------------------------------------------------------------
     GRB_TRY(GrB_Matrix_new(&BS, GrB_FP64, n, n));
     GRB_TRY(GrB_Matrix_new(&S_BS, GrB_FP64, n, n));
+    // GxB_print(S,5);
     GRB_TRY(GrB_mxm(BS, NULL, NULL, stdmxm, B, S, NULL));
+    // GxB_print(BS,5);
     GRB_TRY(GrB_mxm(S_BS,NULL,NULL,stdmxm,S,BS,GrB_DESC_T0));  
     // GxB_print (S_BS,3);
 

experimental/test/test_IsetLouvain.c

@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <acutest.h>
+
+#include <LAGraphX.h>
+#include <LAGraph_test.h>
+#include "LG_Xtest.h"
+
+char msg [LAGRAPH_MSG_LEN];
+LAGraph_Graph G;
+GrB_Matrix A;
+#define LEN 512
+char filename [LEN+1];
+typedef struct
+{
+    const char * matrix_file; //Adjeancy matrix or graph
+    const double mod;
+} matrix_info;
+
+const matrix_info files[] = {
+
+    {"comm0.mtx", 0.357142857142857},
+    // {"res1.mtx", 0.0},
+    // {"karate2.mtx", .42},
+    {"",-1}  
+};
+void test_Louvain(void){
+    LAGraph_Init(msg);
+    printf("\n");
+    for(int k = 0;;k++){
+        if (strlen(files[k].matrix_file) == 0)
+            break;
+        snprintf (filename, LEN, LG_DATA_DIR "%s", files[k].matrix_file) ;
+        FILE *f = fopen (filename, "r") ;
+        TEST_CHECK (f != NULL) ;
+        OK (LAGraph_MMRead (&A, f, msg)) ;
+        OK (LAGraph_New (&G, &A, LAGraph_ADJACENCY_DIRECTED, msg)) ;
+        TEST_CHECK (A == NULL) ;
+
+        // check if the pattern is symmetric - if it isn't make it.
+        OK (LAGraph_Cached_OutDegree (G, msg)) ;
+        OK (LAGraph_Cached_IsSymmetricStructure (G, msg)) ;
+
+        if (G->is_symmetric_structure == LAGraph_FALSE)
+        {
+            printf("This matrix is not symmetric. \n");
+            // make the adjacency matrix symmetric
+            OK (LAGraph_Cached_AT (G, msg)) ;
+            OK (GrB_eWiseAdd (G->A, NULL, NULL, GrB_LOR, G->A, G->AT, NULL)) ;
+            G->is_symmetric_structure = true ;
+            // consider the graph as directed
+            G->kind = LAGraph_ADJACENCY_DIRECTED ;
+        }
+        else
+        {
+            G->kind = LAGraph_ADJACENCY_UNDIRECTED ;
+        }
+        GrB_Matrix S;
+        double tsimple = LAGraph_WallClockTime ( ) ;
+        OK(LAGraph_LouvainMIS(&S,G,msg));
+        tsimple = LAGraph_WallClockTime ( ) - tsimple ;
+        printf(" time: %f\n",tsimple);
+
+
+    }
+}
+TEST_LIST = {
+    {"Louvain", test_Louvain},
+    {NULL, NULL}
+};

experimental/test/test_louvain.c

@@ -19,8 +19,8 @@ typedef struct
 const matrix_info files[] = {
 
     {"comm0.mtx", 0.357142857142857},
-    {"res1.mtx", 0.0},
-    {"karate2.mtx", .42},
+    // {"res1.mtx", 0.0},
+    // {"karate2.mtx", .42},
     {"",-1}  
 };
 //Store matrix by row

include/LAGraphX.h

@@ -1429,6 +1429,18 @@ int LAGraph_IsolateSets(
     uint64_t seed,
     char* msg
 );
+LAGRAPHX_PUBLIC
+int LAGraph_LouvainMIS(
+    //output
+    GrB_Matrix *S_result,
+    //input 
+    LAGraph_Graph G,
+    char* msg
+);
+LAGRAPHX_PUBLIC
+uint64_t LG_Random64 (uint64_t *state);
+
+
 #if defined ( __cplusplus )
 }
 #endif