diff --git a/include/cmr/regular.h b/include/cmr/regular.h index 17f56e1b..51fdc06f 100644 --- a/include/cmr/regular.h +++ b/include/cmr/regular.h @@ -28,6 +28,29 @@ typedef enum CMR_DEC_CONSTRUCT_ALL = 2, } CMR_DEC_CONSTRUCT; +/** + * \brief Flags that control termination of the regular matroid decomposition algorithm. + * + * \see The desired types can be set by modifying \ref CMR_REGULAR_PARAMS.treeFlags. + */ + +typedef enum +{ + CMR_REGULAR_TREE_FLAGS_RECURSE = 1, + /**< Do not process child nodes. */ + CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR = 2, + /**< Stop if a (grand-)child is irregular. */ + CMR_REGULAR_TREE_FLAGS_STOP_NONGRAPHIC = 4, + /**< Stop if a (grand-)child is non-graphic. */ + CMR_REGULAR_TREE_FLAGS_STOP_NONCOGRAPHIC = 8, + /**< Stop if a (grand-)child is non-cographic. */ + CMR_REGULAR_TREE_FLAGS_STOP_NONGRAPHIC_NONCOGRAPHIC = 16, + /**< Stop if a (grand-)child is non-graphic **and** non-cographic. */ + + CMR_REGULAR_TREE_FLAGS_DEFAULT = CMR_REGULAR_TREE_FLAGS_RECURSE | CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR + +} CMR_REGULAR_TREE_FLAGS; + typedef struct { bool directGraphicness; @@ -36,7 +59,10 @@ typedef struct /**< \brief Whether to allow series-parallel operations in the decomposition tree; default: \c true */ bool planarityCheck; /**< \brief Whether minors identified as graphic should still be checked for cographicness; default: \c false. */ - bool completeTree; + + int treeFlags; + /**< \brief Flags controlling the decomposition algorithm. See \ref */ + /**< \brief Whether to compute a complete decomposition tree (even if already non-regular; default: \c false. */ bool threeSumPivotChildren; /**< \brief Whether pivots for 3-sums shall be applied such that the matrix contains both child matrices as diff --git a/src/cmr/matroid.c b/src/cmr/matroid.c index 18785c99..ac0dc975 100644 --- a/src/cmr/matroid.c +++ b/src/cmr/matroid.c @@ -2023,8 +2023,7 @@ CMR_ERROR CMRmatroiddecSetAttributes(CMR_MATROID_DEC* dec) { case CMR_MATROID_DEC_TYPE_UNKNOWN: dec->regularity = 0; - dec->graphicness = 0; - dec->cographicness = 0; + /* We do not set (co)graphicness because its absense may have been determined without setting the type. */ break; case CMR_MATROID_DEC_TYPE_PLANAR: dec->regularity = 1; diff --git a/src/cmr/regular.c b/src/cmr/regular.c index d08daf0e..3883188c 100644 --- a/src/cmr/regular.c +++ b/src/cmr/regular.c @@ -17,7 +17,7 @@ CMR_ERROR CMRregularParamsInit(CMR_REGULAR_PARAMS* params) params->directGraphicness = true; params->seriesParallel = true; params->planarityCheck = false; - params->completeTree = false; + params->treeFlags = CMR_REGULAR_TREE_FLAGS_DEFAULT; params->threeSumPivotChildren = false; params->threeSumStrategy = CMR_MATROID_DEC_THREESUM_FLAG_DISTRIBUTED_RANKS /* TODO: Later no pivots. */ | CMR_MATROID_DEC_THREESUM_FLAG_FIRST_WIDE | CMR_MATROID_DEC_THREESUM_FLAG_FIRST_MIXED @@ -88,7 +88,6 @@ CMR_ERROR CMRregularTest(CMR* cmr, CMR_CHRMAT* matrix, bool *pisRegular, CMR_MAT { assert(cmr); assert(matrix); - assert(pisRegular); CMR_REGULAR_PARAMS defaultParams; if (!params) @@ -100,7 +99,8 @@ CMR_ERROR CMRregularTest(CMR* cmr, CMR_CHRMAT* matrix, bool *pisRegular, CMR_MAT CMR_SUBMAT* submatrix = NULL; if (!CMRchrmatIsBinary(cmr, matrix, pminor ? &submatrix : NULL)) { - *pisRegular = false; + if (pisRegular) + *pisRegular = false; if (pminor) CMR_CALL( CMRminorCreate(cmr, pminor, 0, submatrix) ); return CMR_OKAY; diff --git a/src/cmr/regularity.c b/src/cmr/regularity.c index 3b1895e0..3b0b3ce1 100644 --- a/src/cmr/regularity.c +++ b/src/cmr/regularity.c @@ -49,6 +49,8 @@ CMR_ERROR CMRregularityQueueCreate(CMR* cmr, DecompositionQueue** pqueue) DecompositionQueue* queue = *pqueue; queue->head = NULL; queue->foundIrregularity = false; + queue->foundNongraphicness = false; + queue->foundNoncographicness = false; return CMR_OKAY; } @@ -180,41 +182,16 @@ CMR_ERROR CMRregularityTest(CMR* cmr, CMR_CHRMAT* matrix, bool ternary, bool *pi CMR_CALL( CMRchrmatPrintDense(cmr, matrix, stdout, '0', false) ); #endif /* CMR_DEBUG */ - clock_t time = clock(); - if (stats) - stats->totalCount++; - CMR_MATROID_DEC* root = NULL; CMR_CALL( CMRmatroiddecCreateMatrixRoot(cmr, &root, ternary, matrix) ); assert(root); - DecompositionQueue* queue = NULL; - CMR_CALL( CMRregularityQueueCreate(cmr, &queue) ); - DecompositionTask* rootTask = NULL; - CMR_CALL( CMRregularityTaskCreateRoot(cmr, root, &rootTask, params, stats, time, timeLimit) ); - CMRregularityQueueAdd(queue, rootTask); - - while (!CMRregularityQueueEmpty(queue) && (params->completeTree || !queue->foundIrregularity)) - { - DecompositionTask* task = CMRregularityQueueRemove(queue); - CMR_CALL( CMRregularityTaskRun(cmr, task, queue) ); - } - - CMR_CALL( CMRregularityQueueFree(cmr, &queue) ); + CMR_CALL( CMRregularityCompleteDecomposition(cmr, root, params, stats, timeLimit) ); - CMR_CALL( CMRmatroiddecSetAttributes(root) ); - assert(root->regularity != 0); - if (pisRegular) + if (root->regularity && pisRegular) *pisRegular = root->regularity > 0; - - /* Either store or free the decomposition. */ if (pdec) *pdec = root; - else - CMR_CALL( CMRmatroiddecRelease(cmr, &root) ); - - if (stats) - stats->totalTime += (clock() - time) * 1.0 / CLOCKS_PER_SEC; return CMR_OKAY; } @@ -228,10 +205,10 @@ CMR_ERROR CMRregularityCompleteDecomposition(CMR* cmr, CMR_MATROID_DEC* subtree, #if defined(CMR_DEBUG) CMRdbgMsg(0, "Completing decomposition tree for a %s %zux%zu matrix.\n", - dec->isTernary ? "ternary" : "binary", root->matrix->numRows, root->matrix->numColumns); + subtree->isTernary ? "ternary" : "binary", subtree->matrix->numRows, subtree->matrix->numColumns); CMRdbgMsg(0, "Considered subtree belongs to the %zux%zu matrix.\n", - dec->matrix->numRows, dec->matrix->numColumns); - CMR_CALL( CMRchrmatPrintDense(cmr, dec->matrix, stdout, '0', false) ); + subtree->matrix->numRows, subtree->matrix->numColumns); + CMR_CALL( CMRchrmatPrintDense(cmr, subtree->matrix, stdout, '0', false) ); #endif /* CMR_DEBUG */ clock_t time = clock(); @@ -253,16 +230,56 @@ CMR_ERROR CMRregularityCompleteDecomposition(CMR* cmr, CMR_MATROID_DEC* subtree, CMR_CALL( CMRregularityTaskCreateRoot(cmr, subtree, &decTask, params, stats, time, timeLimit) ); CMRregularityQueueAdd(queue, decTask); - while (!CMRregularityQueueEmpty(queue) && (params->completeTree || !queue->foundIrregularity)) + while (!CMRregularityQueueEmpty(queue)) { DecompositionTask* task = CMRregularityQueueRemove(queue); + + if (!(params->treeFlags & CMR_REGULAR_TREE_FLAGS_RECURSE) && (task->dec != subtree)) + { + CMRdbgMsg(2, "Skipping task for decomposition node %p of size %zux%zu.\n", task->dec, task->dec->numRows, + task->dec->numColumns); + CMR_CALL( CMRregularityTaskFree(cmr, &task) ); + continue; + } + + if ((params->treeFlags & CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR) && queue->foundIrregularity) + { + CMRdbgMsg(2, "Clearing task queue due to an irregular node.\n"); + CMR_CALL( CMRregularityTaskFree(cmr, &task) ); + continue; + } + else if ((params->treeFlags & CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR) && queue->foundIrregularity) + { + CMRdbgMsg(2, "Clearing task queue due to an irregular node.\n"); + CMR_CALL( CMRregularityTaskFree(cmr, &task) ); + continue; + } + else if ((params->treeFlags & CMR_REGULAR_TREE_FLAGS_STOP_NONGRAPHIC) && queue->foundNongraphicness) + { + CMRdbgMsg(2, "Clearing task queue due to a nongraphic node.\n"); + CMR_CALL( CMRregularityTaskFree(cmr, &task) ); + continue; + } + else if ((params->treeFlags & CMR_REGULAR_TREE_FLAGS_STOP_NONCOGRAPHIC) && queue->foundNoncographicness) + { + CMRdbgMsg(2, "Clearing task queue due to a noncographic node.\n"); + CMR_CALL( CMRregularityTaskFree(cmr, &task) ); + continue; + } + else if ((params->treeFlags & CMR_REGULAR_TREE_FLAGS_STOP_NONGRAPHIC_NONCOGRAPHIC) && queue->foundNongraphicness + && queue->foundNoncographicness) + { + CMRdbgMsg(2, "Clearing task queue due to a nongraphic node and a noncographic node.\n"); + CMR_CALL( CMRregularityTaskFree(cmr, &task) ); + continue; + } + CMR_CALL( CMRregularityTaskRun(cmr, task, queue) ); } CMR_CALL( CMRregularityQueueFree(cmr, &queue) ); CMR_CALL( CMRmatroiddecSetAttributes(subtree) ); - assert(subtree->regularity != 0); if (stats) stats->totalTime += (clock() - time) * 1.0 / CLOCKS_PER_SEC; diff --git a/src/cmr/regularity_graphic.c b/src/cmr/regularity_graphic.c index 170aff39..71a849bf 100644 --- a/src/cmr/regularity_graphic.c +++ b/src/cmr/regularity_graphic.c @@ -1705,6 +1705,7 @@ CMR_ERROR CMRregularityNestedMinorSequenceGraphicness(CMR* cmr, DecompositionTas else { dec->graphicness = -1; + queue->foundNongraphicness = true; /* Add task back to list of unprocessed tasks to test cographicness. */ CMRregularityQueueAdd(queue, task); @@ -1788,6 +1789,7 @@ CMR_ERROR CMRregularityNestedMinorSequenceCographicness(CMR* cmr, DecompositionT else { dec->cographicness = -1; + queue->foundNoncographicness = true; /* Add task back to list of unprocessed tasks to search for 3-separations. */ CMRregularityQueueAdd(queue, task); @@ -1860,6 +1862,8 @@ CMR_ERROR CMRregularityTestGraphicness(CMR* cmr, DecompositionTask* task, Decomp dec->graphicness = isGraphic ? 1 : -1; if (isGraphic) dec->type = (dec->type == CMR_MATROID_DEC_TYPE_COGRAPH) ? CMR_MATROID_DEC_TYPE_PLANAR : CMR_MATROID_DEC_TYPE_GRAPH; + else + queue->foundNongraphicness = true; if ((isGraphic && (!task->params->planarityCheck || dec->cographicness)) || dec->cographicness > 0) { @@ -1937,6 +1941,8 @@ CMR_ERROR CMRregularityTestCographicness(CMR* cmr, DecompositionTask* task, Deco dec->cographicness = isCographic ? 1 : -1; if (isCographic) dec->type = (dec->type == CMR_MATROID_DEC_TYPE_GRAPH) ? CMR_MATROID_DEC_TYPE_PLANAR : CMR_MATROID_DEC_TYPE_COGRAPH; + else + queue->foundNoncographicness = true; if ((isCographic && (!task->params->planarityCheck || dec->graphicness)) || dec->graphicness > 0) { diff --git a/src/cmr/regularity_internal.h b/src/cmr/regularity_internal.h index 9239633e..426d115d 100644 --- a/src/cmr/regularity_internal.h +++ b/src/cmr/regularity_internal.h @@ -42,8 +42,10 @@ CMR_ERROR CMRregularityTaskFree( typedef struct DecompositionQueue { - DecompositionTask* head; /**< \brief Next task to be processed. */ - bool foundIrregularity; /**< \brief Whether irregularity was detected for some node. */ + DecompositionTask* head; /**< \brief Next task to be processed. */ + bool foundIrregularity; /**< \brief Whether irregularity was detected for some node. */ + bool foundNongraphicness; /**< \brief Whether non-graphiness was detected for some node. */ + bool foundNoncographicness; /**< \brief Whether non-cographiness was detected for some node. */ } DecompositionQueue; /** diff --git a/src/cmr/regularity_r10.c b/src/cmr/regularity_r10.c index cee722b3..d8b936ce 100644 --- a/src/cmr/regularity_r10.c +++ b/src/cmr/regularity_r10.c @@ -88,6 +88,8 @@ CMR_ERROR CMRregularityTestR10(CMR* cmr, DecompositionTask* task, DecompositionQ } dec->type = CMR_MATROID_DEC_TYPE_R10; + queue->foundNongraphicness = true; + queue->foundNoncographicness = true; cleanup: diff --git a/src/main/regular_main.c b/src/main/regular_main.c index bad9a24e..509a56e6 100644 --- a/src/main/regular_main.c +++ b/src/main/regular_main.c @@ -62,7 +62,8 @@ CMR_ERROR testRegularity( CMR_MINOR* minor = NULL; CMR_REGULAR_PARAMS params; CMR_CALL( CMRregularParamsInit(¶ms) ); - params.completeTree = outputTreeFileName; + params.treeFlags = outputTreeFileName ? (CMR_REGULAR_TREE_FLAGS_RECURSE) + : (CMR_REGULAR_TREE_FLAGS_RECURSE | CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR); params.directGraphicness = directGraphicness; params.seriesParallel = seriesParallel; CMR_REGULAR_STATS stats; diff --git a/src/main/tu_main.c b/src/main/tu_main.c index d36bd490..6e87d7e5 100644 --- a/src/main/tu_main.c +++ b/src/main/tu_main.c @@ -65,7 +65,8 @@ CMR_ERROR testTotalUnimodularity( CMR_TU_PARAMS params; CMR_CALL( CMRtuParamsInit(¶ms) ); params.algorithm = algorithm; - params.regular.completeTree = outputTreeFileName; + params.regular.treeFlags = outputTreeFileName ? (CMR_REGULAR_TREE_FLAGS_RECURSE) + : (CMR_REGULAR_TREE_FLAGS_RECURSE | CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR); params.regular.directGraphicness = directGraphicness; params.regular.seriesParallel = seriesParallel; CMR_TU_STATS stats; diff --git a/test/test_regular.cpp b/test/test_regular.cpp index 11741485..a886abb7 100644 --- a/test/test_regular.cpp +++ b/test/test_regular.cpp @@ -822,3 +822,121 @@ TEST(Regular, R12) ASSERT_CMR_CALL( CMRfreeEnvironment(&cmr) ); } + +TEST(Regular, TreeFlagsNorecurse) +{ + CMR* cmr = NULL; + ASSERT_CMR_CALL( CMRcreateEnvironment(&cmr) ); + + { + CMR_CHRMAT* matrix = NULL; + ASSERT_CMR_CALL( stringToCharMatrix(cmr, &matrix, "9 9 " + " 1 1 0 0 0 0 0 0 0 " + " 1 1 1 0 0 0 0 0 0 " + " 1 0 0 1 0 0 0 0 0 " + " 0 1 1 1 0 0 0 0 0 " + " 0 0 1 1 0 0 0 0 0 " + " 0 0 0 0 1 1 1 0 0 " + " 0 0 0 0 1 1 0 1 0 " + " 0 0 0 0 0 1 0 1 1 " + " 0 0 0 0 0 0 1 1 1 " + ) ); + + ASSERT_CMR_CALL( CMRchrmatPrintDense(cmr, matrix, stdout, '0', true) ); + + CMR_MATROID_DEC* dec = NULL; + CMR_REGULAR_PARAMS params; + ASSERT_CMR_CALL( CMRregularParamsInit(¶ms) ); + params.treeFlags = CMR_REGULAR_TREE_FLAGS_STOP_IRREGULAR; + + ASSERT_CMR_CALL( CMRregularTest(cmr, matrix, NULL, &dec, NULL, ¶ms, NULL, DBL_MAX) ); + ASSERT_EQ( CMRmatroiddecType(dec), CMR_MATROID_DEC_TYPE_ONE_SUM ); + ASSERT_EQ( CMRmatroiddecType(CMRmatroiddecChild(dec, 0)), CMR_MATROID_DEC_TYPE_UNKNOWN ); + ASSERT_EQ( CMRmatroiddecType(CMRmatroiddecChild(dec, 1)), CMR_MATROID_DEC_TYPE_UNKNOWN ); + + ASSERT_CMR_CALL( CMRmatroiddecRelease(cmr, &dec) ); + ASSERT_CMR_CALL( CMRchrmatFree(cmr, &matrix) ); + } + + ASSERT_CMR_CALL( CMRfreeEnvironment(&cmr) ); +} + +TEST(Regular, TreeFlagsStopNoncographic) +{ + CMR* cmr = NULL; + ASSERT_CMR_CALL( CMRcreateEnvironment(&cmr) ); + + { + CMR_CHRMAT* matrix = NULL; + ASSERT_CMR_CALL( stringToCharMatrix(cmr, &matrix, "9 9 " + " 1 1 0 0 0 0 0 0 0 " + " 1 1 1 0 0 0 0 0 0 " + " 1 0 0 1 0 0 0 0 0 " + " 0 1 1 1 0 0 0 0 0 " + " 0 0 1 1 0 0 0 0 0 " + " 0 0 0 0 1 1 1 0 0 " + " 0 0 0 0 1 1 0 1 0 " + " 0 0 0 0 0 1 0 1 1 " + " 0 0 0 0 0 0 1 1 1 " + ) ); + + ASSERT_CMR_CALL( CMRchrmatPrintDense(cmr, matrix, stdout, '0', true) ); + + CMR_MATROID_DEC* dec = NULL; + CMR_REGULAR_PARAMS params; + ASSERT_CMR_CALL( CMRregularParamsInit(¶ms) ); + params.treeFlags = CMR_REGULAR_TREE_FLAGS_RECURSE | CMR_REGULAR_TREE_FLAGS_STOP_NONCOGRAPHIC; + params.planarityCheck = true; + + ASSERT_CMR_CALL( CMRregularTest(cmr, matrix, NULL, &dec, NULL, ¶ms, NULL, DBL_MAX) ); + ASSERT_EQ( CMRmatroiddecType(dec), CMR_MATROID_DEC_TYPE_ONE_SUM ); + ASSERT_EQ( CMRmatroiddecType(CMRmatroiddecChild(dec, 0)), CMR_MATROID_DEC_TYPE_GRAPH ); + ASSERT_EQ( CMRmatroiddecType(CMRmatroiddecChild(dec, 1)), CMR_MATROID_DEC_TYPE_UNKNOWN ); + ASSERT_LT( CMRmatroiddecCographicness(dec), 0 ); + + ASSERT_CMR_CALL( CMRmatroiddecRelease(cmr, &dec) ); + ASSERT_CMR_CALL( CMRchrmatFree(cmr, &matrix) ); + } + + ASSERT_CMR_CALL( CMRfreeEnvironment(&cmr) ); +} + + +TEST(Regular, TreeFlagsStopNongraphic) +{ + CMR* cmr = NULL; + ASSERT_CMR_CALL( CMRcreateEnvironment(&cmr) ); + + { + CMR_CHRMAT* matrix = NULL; + ASSERT_CMR_CALL( stringToCharMatrix(cmr, &matrix, "9 9 " + " 1 1 1 0 0 0 0 0 0 " + " 1 1 0 1 0 0 0 0 0 " + " 0 1 0 1 1 0 0 0 0 " + " 0 0 1 1 1 0 0 0 0 " + " 0 0 0 0 0 1 1 0 0 " + " 0 0 0 0 0 1 1 1 0 " + " 0 0 0 0 0 1 0 0 1 " + " 0 0 0 0 0 0 1 1 1 " + " 0 0 0 0 0 0 0 1 1 " + ) ); + + ASSERT_CMR_CALL( CMRchrmatPrintDense(cmr, matrix, stdout, '0', true) ); + + CMR_MATROID_DEC* dec = NULL; + CMR_REGULAR_PARAMS params; + ASSERT_CMR_CALL( CMRregularParamsInit(¶ms) ); + params.treeFlags = CMR_REGULAR_TREE_FLAGS_RECURSE | CMR_REGULAR_TREE_FLAGS_STOP_NONGRAPHIC; + params.planarityCheck = true; + + ASSERT_CMR_CALL( CMRregularTest(cmr, matrix, NULL, &dec, NULL, ¶ms, NULL, DBL_MAX) ); + ASSERT_EQ( CMRmatroiddecType(dec), CMR_MATROID_DEC_TYPE_ONE_SUM ); + ASSERT_LT( CMRmatroiddecGraphicness(dec), 0 ); + + ASSERT_CMR_CALL( CMRmatroiddecRelease(cmr, &dec) ); + ASSERT_CMR_CALL( CMRchrmatFree(cmr, &matrix) ); + } + + ASSERT_CMR_CALL( CMRfreeEnvironment(&cmr) ); +} + diff --git a/test/test_tu.cpp b/test/test_tu.cpp index dc55f16b..b5aedbe7 100644 --- a/test/test_tu.cpp +++ b/test/test_tu.cpp @@ -1287,7 +1287,7 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - params.regular.completeTree = true; + params.regular.treeFlags = CMR_REGULAR_TREE_FLAGS_RECURSE; ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1324,7 +1324,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1369,7 +1368,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); params.regular.directGraphicness = false; ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1415,7 +1413,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1464,7 +1461,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); params.regular.directGraphicness = false; ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1511,7 +1507,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1557,7 +1552,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) ); @@ -1604,7 +1598,6 @@ TEST(TU, CompleteTree) CMR_MATROID_DEC* dec = NULL; CMR_TU_PARAMS params; ASSERT_CMR_CALL( CMRtuParamsInit(¶ms) ); - ASSERT_FALSE( params.regular.completeTree ); ASSERT_CMR_CALL( CMRtuTest(cmr, matrix, &isTU, &dec, NULL, ¶ms, NULL, DBL_MAX) );