testing of maximum/maximal matching/etc

Author: DrTimothyAldenDavis

experimental/algorithm/LAGr_MaximumMatching.c

@@ -451,6 +451,7 @@ invert_2(GrB_Vector out,  // input/output
         GrB_free(&getRootsOp);                                                 \
         GrB_free(&parentsUpdate);                                              \
         GrB_free(&ufrontierR);                                                 \
+        GrB_free(&mateC);                                                      \
         GrB_free(&mateR);                                                      \
         GrB_free(&rootsufR);                                                   \
         GrB_free(&pathUpdate);                                                 \
@@ -945,13 +946,16 @@ int LAGr_MaximumMatching(
     } while (npath); // only in the first and last iteration should this
                      // condition be false
 
+    // return result
     if (mateC_handle != NULL)
     {
         (*mateC_handle) = mateC;
+        mateC = NULL ;
     }
     if (mateR_handle != NULL)
     {
         (*mateR_handle) = mateR;
+        mateR = NULL ;
     }
     LG_FREE_WORK;
 

experimental/algorithm/LAGraph_MaximalIndependentSet.c

@@ -300,7 +300,8 @@ int LAGraph_MaximalIndependentSet       // maximal independent set
             // This case is nearly untestable since it can almost never occur.
             nstall++ ;
             // terminate if the method has stalled too many times
-            LG_ASSERT_MSG (nstall <= 32, -111, "stall") ;
+            LG_ASSERT_MSG (nstall <= 32, LAGRAPH_CONVERGENCE_FAILURE,
+                "method has stalled") ;
             // recreate the random number seeds with a new starting seed
             LG_TRY (LAGraph_Random_Seed (Seed, seed + nstall, msg)) ;
         }

experimental/algorithm/LAGraph_MaximalMatching.c

@@ -240,12 +240,16 @@ int LAGraph_MaximalMatching
 
         if (max_degree > 1) {
             nfailures++ ;
+            LG_ASSERT_MSG (nfailures <= MAX_FAILURES, LAGRAPH_CONVERGENCE_FAILURE,
+                "method has stalled") ;
+#if 0
             if (nfailures > MAX_FAILURES) {
     #ifdef dbg
                 printf("[DBG] hit max failures %d\n", nfailures);
     #endif
-                break ; // FIXME: test coverage doesn't test this case.  Is it possible?
+                break ; // test coverage doesn't test this case.  Is it possible?
             }
+#endif
             // regen seed and seed vector
             LG_TRY (LAGraph_Random_Seed (Seed, seed + nfailures, msg)) ;
             continue ;

experimental/test/test_MaximalIndependentSet.c

@@ -225,7 +225,7 @@ void test_MIS (void)
         result = LAGraph_MaximalIndependentSet (&mis, G, 0, NULL, msg) ;
         random_hack = false ;
         printf ("hack msg: %d %s\n", result, msg) ;
-        TEST_CHECK (result == -111 || result == 0) ;
+        TEST_CHECK (result == LAGRAPH_CONVERGENCE_FAILURE || result == 0) ;
         if (result == 0)
         {
             OK (LG_check_mis (G->A, mis, NULL, msg)) ;

experimental/test/test_MaximumMatching.c

@@ -19,6 +19,19 @@ const char *filenames[NTESTS] = {"random_weighted_bipartite2.mtx",
                                  "lp_afiro_structure.mtx", "sources_7.mtx"};
 const uint64_t spranks[NTESTS] = {298, 2009, 14, 27, 1};
 
+#if 0
+#undef OK
+#define OK(method) \
+{ \
+    GrB_Info info2 = method ; \
+    if (info2 != GrB_SUCCESS) \
+    { \
+        printf ("info: %d, msg: %s\n", info2, msg) ; \
+        TEST_CHECK (false) ; \
+    } \
+}
+#endif
+
 void test_MCM(void)
 {
     LAGraph_Init(msg);
@@ -32,6 +45,7 @@ void test_MCM(void)
         for (uint64_t test = 0; test < NTESTS; test++)
         {
 
+            printf ("\n%s =======================\n", filenames [test]) ;
             GrB_Matrix A = NULL;
             GrB_Matrix AT = NULL;
             snprintf(filename, LEN, LG_DATA_DIR "%s", filenames[test]);
@@ -71,12 +85,16 @@ void test_MCM(void)
             OK(GrB_Vector_new(&mateC, GrB_UINT64, ncols));
 
             GrB_Vector mateC_init = NULL;
+            GrB_Vector mateR_init = NULL;
 
             if (!strcmp(filenames[test], "lp_afiro_structure.mtx"))
             {
                 OK(GrB_Vector_new(&mateC_init, GrB_UINT64, ncols));
+                OK(GrB_Vector_new(&mateR_init, GrB_UINT64, nrows));
                 OK(GrB_Vector_setElement_UINT64(
                     mateC_init, 0, 19)); // col 20 matched with row 1 (1-based)
+                OK(GrB_Vector_setElement_UINT64(
+                    mateR_init, 19, 0)); // col 20 matched with row 1 (1-based)
                 OK(GrB_Matrix_new(&AT, GrB_BOOL, ncols,
                                   nrows)); // transpose matrix has the reverse
                                            // dimensions from the original
@@ -85,7 +103,7 @@ void test_MCM(void)
 
             OK(LAGr_MaximumMatching(&mateC, NULL, A, AT, mateC_init, true,
                                     msg));
-            printf("\nmsg: %s\n", msg);
+//          printf("\nmsg: %s\n", msg);
 
             GrB_Index nmatched = 0;
 
@@ -105,6 +123,7 @@ void test_MCM(void)
             // if nvals of mateC and mateR don't match, then there's at least
             // one row that is used in at least one matching
             TEST_CHECK(nmatched == nmateR);
+            printf ("# of matches: %" PRIu64 "\n", nmatched) ;
 
             // pack matched values in a matrix
             GrB_Matrix M = NULL;
@@ -128,11 +147,44 @@ void test_MCM(void)
             // sprank must be equal to nvals of mateC (nmatched)
             TEST_CHECK(nmatched == spranks[test]);
 
-            OK(GrB_Vector_free(&mateC));
-            OK(GrB_Vector_free(&mateR));
-            OK(GrB_Matrix_free(&M));
-            OK(GrB_Matrix_free(&A));
-            OK(GrB_Matrix_free(&AT));
+            OK(GrB_free(&mateC));
+            OK(GrB_free(&mateR));
+            OK(GrB_free(&M));
+
+            // return both mateR and mateC
+            OK(LAGr_MaximumMatching(&mateC, &mateR, A, AT, mateC_init, true,
+                                    msg));
+            GrB_Index nmateC = 0 ;
+            nmateR = 0 ;
+            OK(GrB_Vector_nvals(&nmateC, mateC));
+            OK(GrB_Vector_nvals(&nmateR, mateR));
+            TEST_CHECK(nmateC == nmateR);
+            TEST_CHECK(nmateC == nmatched);
+            OK(GrB_free(&mateC));
+            OK(GrB_free(&mateR));
+
+            // ensure AT exists, and pass in AT only, and use mateR_init
+            if (AT == NULL)
+            {
+                OK(GrB_Matrix_new(&AT, GrB_BOOL, ncols, nrows));
+                OK(GrB_transpose(AT, NULL, NULL, A, NULL));
+            }
+            OK(LAGr_MaximumMatching(&mateC, &mateR, NULL, AT, mateR_init, false,
+                                    msg));
+            nmateC = 0 ;
+            nmateR = 0 ;
+            OK(GrB_Vector_nvals(&nmateC, mateC));
+            OK(GrB_Vector_nvals(&nmateR, mateR));
+            TEST_CHECK(nmateC == nmateR);
+            TEST_CHECK(nmateC == nmatched);
+            OK(GrB_free(&mateC));
+            OK(GrB_free(&mateR));
+
+            OK(GrB_free(&mateC_init));
+            OK(GrB_free(&mateR_init));
+            OK(GrB_free(&A));
+            OK(GrB_free(&AT));
+
         }
     }
     LAGraph_Finalize(msg);