Only apply upper bound algorithm when it is applicable

src/DistributeMat.c

 #include "DistributeMat.h"
 #include "Permute.h"
-#include "FreeNonzeros.h"
-#include "SplitMatrixUpperBound.h"
 
 #ifdef USE_PATOH
 #include <patoh.h>
@@ -684,20 +682,31 @@ int DistributeMatrixMondriaan(struct sparsematrix *pT, int P, double eps, const
 #endif
     
     if(pOptions->CheckUpperBound == CheckUpperBoundYes) {
-        /* Compute volume. It should be at most (min(m,n)+1)(P-1) */
-        long ComVol1, ComVol2, tmp;
-        CalcCom(pT, NULL, (pT->m < pT->n)?ROW:COL, &ComVol1, &tmp, &tmp, &tmp, &tmp);
-        CalcCom(pT, NULL, (pT->m < pT->n)?COL:ROW, &ComVol2, &tmp, &tmp, &tmp, &tmp);
-        long upperBound = (((pT->m < pT->n)?pT->m:pT->n)+1)*(P-1);
+        /* Check whether we can apply the upper bound algorithm */
+        int isSymmetric   = ((pT->MMTypeCode[3]=='S' || pT->MMTypeCode[3]=='K' || pT->MMTypeCode[3]=='H') &&
+                             pOptions->SymmetricMatrix_UseSingleEntry == SingleEntYes);
+        int hasDummies    = (pT->NrDummies > 0);
+        int isColWeighted = (pT->MMTypeCode[0] == 'W' && pT->NrColWeights > 0);
         
-        if(ComVol1+ComVol2 > upperBound) {
+        /* To support OrderPermutation, new code should be written to recompute the permutation from scratch */
+        int orderPermute  = (pOptions->OrderPermutation != OrderNone);
+        
+        if(!isSymmetric && !hasDummies && !isColWeighted && !orderPermute) {
+            /* Compute volume. It should be at most (min(m,n)+1)(P-1) */
+            long ComVol1, ComVol2, tmp;
+            CalcCom(pT, NULL, (pT->m < pT->n)?ROW:COL, &ComVol1, &tmp, &tmp, &tmp, &tmp);
+            CalcCom(pT, NULL, (pT->m < pT->n)?COL:ROW, &ComVol2, &tmp, &tmp, &tmp, &tmp);
+            long upperBound = (((pT->m < pT->n)?pT->m:pT->n)+1)*(P-1);
+            
+            if(ComVol1+ComVol2 > upperBound) {
 #ifdef INFO
-            printf("Info: Achieved volume %ld is larger than upper bound %ld. Attempting to generate upper bound solution.\n", ComVol1+ComVol2, upperBound);
+                printf("Info: Achieved volume %ld is larger than upper bound %ld. Attempting to generate upper bound solution.\n", ComVol1+ComVol2, upperBound);
 #endif
-            if (!SplitMatrixUpperBound(pT, P, pOptions)) {
-                fprintf(stderr, "DistributeMatrixMondriaan(): Unable to compute upper bound solution!\n");
+                if (!SplitMatrixUpperBound(pT, P, pOptions)) {
+                    fprintf(stderr, "DistributeMatrixMondriaan(): Unable to compute upper bound solution!\n");
+                }
+                k = P;
             }
-            k = P;
         }
     }
     

src/DistributeMat.h

@@ -8,6 +8,8 @@
 #include "SparseMatrix.h"
 #include "Remembrance.h"
 #include "ZeroVolumeSearch.h"
+#include "FreeNonzeros.h"
+#include "SplitMatrixUpperBound.h"
 
 /* Function declarations for DistributeMat.c */
 long ComputeWeight(const struct sparsematrix *pT, long lo, long hi, long *wnz, const struct opts *pOptions);

src/SplitMatrixUpperBound.c

@@ -414,6 +414,10 @@ int SplitMatrixUpperBound(struct sparsematrix *pT, int P, const struct opts *pOp
     }
 #endif
     
+    /* Compute new lambdas */
+    InitNprocs(pT, COL, pT->RowLambda);
+    InitNprocs(pT, ROW, pT->ColLambda);
+    
     return TRUE;
 } /* end SplitMatrixUpperBound */
 

src/SplitMatrixUpperBound.h

+#ifndef __SplitMatrixUpperBound_h__
+#define __SplitMatrixUpperBound_h__
+
 #include "Heap.h"
 #include "DistributeVecLib.h"
 
 int SplitMatrixUpperBound(struct sparsematrix *pT, int P, const struct opts *pOptions);
 int CheckUpperBoundSolution(struct sparsematrix *pT);
+
+#endif /* __SplitMatrixUpperBound_h__ */