tclosure matbe ready

Author: giovmanz

b128.h

@@ -49,7 +49,7 @@ size_t mshow_stats(size_t size, size_t asize, const b128mat_t *a, const char *mn
 // check if two b128 compressed matrices :a and :b are equal
 // if a==b return -1
 // if a!=b return the row index>=0 containing the first difference
-int mequals(size_t size, const b128mat_t *a, const b128mat_t *b);
+int mequals_plain(size_t size, const b128mat_t *a, const b128mat_t *b);
 // sum two b128 matrices a and b writing the result to c
 // multiplication is done replacing scalar + by logical or 
 void msum(size_t asize, const b128mat_t *a, const b128mat_t *b, b128mat_t *c);

b128ops.c

@@ -159,16 +159,23 @@ size_t mshow_stats(size_t size, size_t asize, const b128mat_t *a, const char *mn
 // check if two b128 compressed matrices :a and :b are equal
 // if a==b return -1
 // if a!=b return the row index>=0 containing the first difference
-int mequals(size_t size, const b128mat_t *a, const b128mat_t *b)
+int mequals_plain(size_t size, const b128mat_t *a, const b128mat_t *b)
 {
   (void) size;
   assert(a!=NULL && b!=NULL);
-  assert(a->size!=b->size);
+  assert(a->size==b->size);
   for(size_t i=0; i<a->size*a->colb; i++)
     if(a->b[i]!=b->b[i]) return (int) (i/a->colb); // return row number of first difference
   return -1;
 }
 
+// as above but return true if a and b are equal, false otherwise
+bool mequals(const b128mat_t *a, const b128mat_t *b) {
+  assert(a!=NULL && b!=NULL);
+  if(a->size != b->size) return false; // cannot say
+  return mequals_plain(0, a, b) < 0;
+}
+
 
 
 // matrix addition

k2.h

@@ -136,8 +136,10 @@ void mmake_pointer(const k2mat_t *a, k2mat_t *c);
 // if :a or :b have backp or main_diag, result is unknow and return INT32_MAX
 // otherwise if a==b return -d, where d>0 is the number of levels traversed  
 //           if a!=b return the level>=0 containing the first difference
-// Note that the results of sum and product operations never have backpoiners
-int mequals(size_t size, const k2mat_t *a, const k2mat_t *b);
+// Note that the results of sum and product operations never have backpointers
+int mequals_plain(size_t size, const k2mat_t *a, const k2mat_t *b);
+// as above but return a bool
+bool mequals(const k2mat_t *a, const k2mat_t *b);
 // return number of levels in the k2tree associated to a
 int k2tree_levels(size_t size, const k2mat_t *a);
 // copy the (submatrix) :a to :b resolving all backpointers and main_diag_1 flag

k2cpdf.c

@@ -164,7 +164,7 @@ int main(int argc, char* argv[]) {
           printf("   %zd (input) vs %zd (decompressed)\n",nz,nz_check_a);
           exit(1);
         }
-        int d = mequals(a.fullsize, &a, &check_a);
+        int d = mequals_plain(a.fullsize, &a, &check_a);
         if(d < 0) {
             if(verbose) printf("## Correct decompression!\n");
         } else {

k2io.c

@@ -100,7 +100,7 @@ size_t mshow_stats(const k2mat_t *a, const char *mname,FILE *file) {
   fprintf(file," Tree size: %zu bytes, %zu bits, Bits x nonzero: %lf\n",
           (pos+1)/2 , 4*pos, 4.0*(double)(pos)/(double) nz);
   fprintf(file, " Total space (bits): %zu, Bits x nonzero: %lf\n", 
-      pos * 4 + bits_r + bits_p, (double) (pos * 4 + bits_r + bits_p) / (double) nz);
+      pos * 4 + bits_r + bits_p + bits_sub, (double) (pos * 4 + bits_r + bits_p + bits_sub) / (double) nz);
   return nz;
 }
 

k2ops.c

@@ -116,7 +116,7 @@ static int k2tree_equals_rec(size_t size, const k2mat_t *a, size_t *posa,
 // note: here all 0's matrices are considered of depth 1 even if they are empty
 // only the tree strucure is considered, not the main diagonal flag or backpointers
 // TODO: use k2copy_normalize to compare any pair of matrices 
-int mequals(size_t size, const k2mat_t *a, const k2mat_t *b)
+int mequals_plain(size_t size, const k2mat_t *a, const k2mat_t *b)
 {
   assert(size>=2*MMsize);
   assert(a!=NULL && b!=NULL);
@@ -139,6 +139,15 @@ int mequals(size_t size, const k2mat_t *a, const k2mat_t *b)
 }
 
 
+// as above but return true if a and b are equal, false otherwise
+// todo: delete mequals_plain and use this one everywhere
+bool mequals(const k2mat_t *a, const k2mat_t *b) {
+  assert(a!=NULL && b!=NULL);
+  if(a->fullsize != b->fullsize) return false; 
+    if(a->realsize != b->realsize) return false; 
+  return mequals_plain(a->fullsize, a, b) < 0;
+}
+
 // return number of levels in the k2_tree storing matrix :a
 // only the tree structure is considered, not the main_diagonal flag or backpointers
 // note: root with no children: 1 level 

k2tclosure.c

@@ -130,7 +130,9 @@ int main (int argc, char **argv) {
   assert(a.backp==NULL);
   #endif
 
+  int iter=0;
   while(true) {
+    if(verbose) printf("## Iteration %d\n", iter); iter++;
     #ifdef K2MAT
       // compute subtree info and write to file
       vu64_t z;      // resizable array to contain the subtree sizes
@@ -149,6 +151,7 @@ int main (int argc, char **argv) {
         if(node_limit < min_node_limit) node_limit = min_node_limit; // minimum node limit (ensure at least 2 levels)
         if(verbose) printf("Computing sizes for subtrees larger than %zu nodes\n", node_limit);
         p = k2dfs_sizes_limit(a.fullsize,&a,&pos,&z,(size_t)node_limit); // visit tree, compute and save subtree sizes in z 
+        node_limit =0; // reset for next iterqation
       }
       a.subtinfo_size = z.n; 
       a.subtinfoarray = a.subtinfo = z.v; // save subtree info in a
@@ -162,13 +165,13 @@ int main (int argc, char **argv) {
     if(verbose) printf("Multiplying (A+I)A\n");
     mmult(&b,&a,&aIa); // aIa = (a+I)a
     if(verbose) printf("Checking if fixed point\n");
-    int eq = mequals(a.fullsize, &a,&aIa);
-    if(eq <0) break;
+    if(mequals(&a,&aIa)==true) break;
     k2mat_t temp = a; a = aIa; aIa = temp; // swap a and aIa for the next iteration
     matrix_free(&aIa);   
   }
   if(verbose) printf("Fixed point reached, stopping\n");
   if(verbose)  mshow_stats(&aIa,"Transitive closure matrix",stdout);  
+  msave_to_file(&aIa, oname);
   // done
   matrix_free(&aIa);  
   matrix_free(&a);    

makefile

@@ -41,7 +41,7 @@ k2pagerank.o: k2pagerank.c k2.h
 k2cpdf.x: k2cpdf.o k2ops.o bbm.o vu64.o  pointers.o rank_0000.o libsais/liblibsais.a
 	$(CC) $(LDFLAGS) -o $@ $^ 
 
-k2ops.o: k2ops.c k2text.c k2aux.c minimats.c k2.h bbm.h
+k2ops.o: k2ops.c k2text.c k2aux.c k2io.c minimats.c k2.h bbm.h
 	$(CC) $(CFLAGS) $(EXTRA) -c -o $@ $<
 
 pointers.o:  pointers.c pointers.h