comparing b128 annd k2

Author: giovmanz

.github/workflows/c.yml

@@ -24,12 +24,22 @@ jobs:
     - name: run
       run: ./prodtest.sh web cnr80k eu80k goo80k goo120k
 
-    - name: uncomporess
+    - name: uncompress 
       run: |
           ./k2sparse.x -d web/cnr80k.k2 -o web/cnr80k.txt   
           ./k2sparse.x -d web/eu80k.k2 -o web/eu80k.txt   
           ./k2sparse.x -d web/goo80k.k2 -o web/goo80k.txt   
-          ./k2sparse.x -d web/goo120k.k2 -o web/goo120k.txt   
+          ./k2sparse.x -d web/goo120k.k2 -o web/goo120k.txt  
+
+    - name: b128 test
+          util/sparsetr -s 40000 web/cnr80k.txt -o web/cnr40k.txt  
+          ./b128sparse.x -s 40000 web/cnr40k.txt -o web/cnr40k.b128
+          ./b128unary.x web/cnr40k.b128    
+          ./matrixcmp.x web/cnr40k.txt web/cnr40k.b128.0.txt
+          ./k2sparse.x web/cnr40k.txt -o web/cnr40k.k2
+          ./k2unary.x web/cnr40k.k2
+          ./matrixcmp.x web/cnr40k.txt web/cnr40k.k2.0.txt
+          ./matrixcmp.x web/cnr40k.b128.1sq.txt web/cnr40k.k2.1sq.txt
 
     - name: big transpose test 
       run: ./sumtest.sh web/*.txt

.vscode/launch.json

@@ -35,8 +35,8 @@
       "request": "launch",
       "program": "${fileDirname}/k2unary.x",
       //"args": [ "-o", "tmp/poli3.2", "-I", "tmp/poli3.ck2.p", "tmp/poli3.ck2"
-      // "args": [ "-o", "web/cnr80k.txt.2", "web/cnr80k.txt.k2"
-      "args": [ "-o", "web/cnr80k.txt.2", "web/cnr80k.txt.ck2", "-I", "web/cnr80k.txt.ck2.p"
+      "args": [ "-o", "web/goo120k.txt.2", "web/goo120k.txt.k2"
+      // "args": [ "-o", "web/cnr80k.txt.2", "web/cnr80k.txt.ck2", "-I", "web/cnr80k.txt.ck2.p"
       ],
       "stopAtEntry": true,
       "cwd": "${fileDirname}",

k2aux.c

@@ -529,15 +529,15 @@ k2mat_t k2jump(size_t size, const k2mat_t *a)
 // the submatrices are not minimats since we are not at the last level of the tree
 // :a is not all 0's, it could be all 1's 
 // note: a could be open ended
-// backpointer should have been already followed
+// backpointers should have been already followed
 // main_diag_1 if present is transmitted to the diagonmal submatrices 
 void k2split_k2(const k2mat_t *a, k2mat_t b[2][2])
 {
   assert(a!=NULL && b!=NULL);
   size_t size = a->fullsize;
   assert(size>2*MMsize);
   assert(size%2==0);
-  assert(a->main_diag_1==false || a->realsize>0); // if main_dag real size mus be well defined 
+  assert(a->main_diag_1==false || a->realsize>0); // if main_diag real size mus be well defined 
   assert(a->open_ended || !k2is_empty(a)); // k2is_empty cannot be called for an open ended matrix
   // init size 
   for(int i=0;i<4;i++) {
@@ -618,7 +618,7 @@ void k2split_k2(const k2mat_t *a, k2mat_t b[2][2])
       subt_size[0] = k2treesize(a)-1;
     else { // if treesize not available compute subtree size with a visit 
       size_t next=pos;
-      k2dfs_visit_fast(size/2,a,&next);
+      k2dfs_visit_fast(size/2,a,&next); // it would do the same visit later
       subt_size[0] = next - pos;
     }    
   }
@@ -629,9 +629,9 @@ void k2split_k2(const k2mat_t *a, k2mat_t b[2][2])
     int i=k/2; int j=k%2;
     if(root & (1<<k)) { // k-th child is non empty
       if(a->subtinfo || nchildren==1) next = pos + subt_size[child]; // jump to end of submatrix
-      else k2dfs_visit_fast(size/2,a,&next);  // move to end of submatrix
-      k2clone_submatrix(a, pos, next, &b[i][j]);        // create pointer to submatrix
-      pos = next;                             // advance to next item
+      else k2dfs_visit_fast(size/2,a,&next);      // move to end of submatrix
+      k2clone_submatrix(a, pos, next, &b[i][j]);  // create pointer to submatrix
+      pos = next;                                 // advance to next item
       if(a->subtinfo) {
         b[i][j].subtinfo = subt_info[child];    // save subtinfo if available
         b[i][j].subtinfo_size = subt_info_size[child++];  // save subtinfo_size and advance child
@@ -650,7 +650,7 @@ void k2split_k2(const k2mat_t *a, k2mat_t b[2][2])
       b[1][1].realsize = a->realsize - size/2;
     }
     else {
-      b[0][0].realsize = size/2; // b[1][1] has not main_diag_1
+      b[0][0].realsize = a->realsize; // b[1][1] has not main_diag_1
     }
     assert(b[0][0].realsize <= b[0][0].fullsize);
     assert(b[1][1].realsize <= b[1][1].fullsize);

k2ops.c

@@ -210,7 +210,7 @@ void k2copy_normalise(const k2mat_t *a, k2mat_t *b)
   // if :a has main diag build ad-hoc identity 
   // and normalize by multiplication
   if(a->main_diag_1) {
-    k2mat_t c = mat_identity(a->realsize);
+    k2mat_t c = mat_identity(a);
     mmult(a,&c,b); 
     k2_free(&c);
   }
@@ -243,9 +243,7 @@ k2mat_t mat_zero(const k2mat_t *b) {
 
 // creates a size x size identity matrix
 k2mat_t mat_identity(const k2mat_t *b) {
-  k2mat_t a = K2MAT_INITIALIZER;
-  a.realsize = b->realsize;
-  a.fullsize = b->fullsize;
+  k2mat_t a = mat_zero(b);
   madd_identity(&a);
   return a;
 }
@@ -714,7 +712,7 @@ void mvmult_slow(size_t asize, const k2mat_t *a, size_t size, double *x, double
 // the case in which :a or b: are empty (all 0's or Identity) is handled in the caller
 // the case size==2*MMsize is handled in the caller 
 // main_diag_1 flag is handled by k2split_k2() 
-// :a or b: can be backpointers, the are habdled by k2jump
+// :a or b: can be backpointers, they are handled by k2jump
 static void split_and_rec(size_t size, const k2mat_t *a, const k2mat_t *b, k2mat_t *c)
 {
   assert(size>2*MMsize);

k2text.c

@@ -970,7 +970,8 @@ static void mdecode_to_textfile(FILE *outfile, size_t msize, size_t i, size_t j,
   assert(c->offset==0);   // we are never working on submatrices 
   assert(size%2==0 && size>=2*MMsize);
   assert(i%MMsize==0 && j%MMsize==0);
-  assert(i<msize+2*size && j<msize+2*size);
+  // assert(i<msize+2*size && j<msize+2*size); // I can remember why the +2*size was needed, see following line
+  assert(i<msize && j<msize);
   assert(!c->main_diag_1 || i==j); // if main_diag_1 is on we must be on a diagonal submatrix
 
   if(size==2*MMsize) { // base case

k2unary.c

@@ -29,8 +29,6 @@
  bool Use_all_ones_node; // not used: added for compatibility with k2mat
  bool Extended_edf;      // not used: added for compatibility with k2mat
 #endif
-// used by both matrix types
-#define default_ext ".unary"
 
 // static functions at the end of the file
 static void usage_and_exit(char *name);
@@ -115,16 +113,16 @@ int main (int argc, char **argv) {
 
   // add main diagonal 1's
   madd_identity(&a);
-  // printf("Caution: madd_identity may add 1's also outside the original matrix size!\n");
   sprintf(oname,"%s.1.txt",outfile);
+  if(verbose)  mshow_stats(&a,oname,stdout);
   mwrite_to_textfile(&a, oname);
 
-  // squaring 
+  // squaring (using a single copy of the :a matrix)
   k2mat_t asq = K2MAT_INITIALIZER;
   mmult(&a,&a,&asq);
   if(verbose)   mshow_stats(&asq,"(A+I)^2",stdout);
   sprintf(oname,"%s.1sq.txt",outfile);
-  msave_to_file(&asq,oname);
+  mwrite_to_textfile(&asq,oname);
 
   // done
   matrix_free(&a);    
@@ -141,16 +139,14 @@ static void usage_and_exit(char *name)
     fprintf(stderr,"Usage:\n\t  %s [options] infile\n\n",name);
     fprintf(stderr,"Demo of unary operations on the compressed matrices stored in infile\n\n");
     fputs("Options:\n",stderr);
-    fprintf(stderr,"\t-n        do not write output file, only show stats\n");    
-    fprintf(stderr,"\t-o out    outfile name (def. infile%s)\n",default_ext);
+    fprintf(stderr,"\t-o out    outfile base name (def. infile)\n");
     #ifdef K2MAT
     fprintf(stderr,"\t-i info   infile subtree info file\n");
     fprintf(stderr,"\t-I info   infile backpointers file\n");
     fprintf(stderr,"\t-r size   rank block size for k2 compression (def. 64)\n");
     fprintf(stderr,"\t-e        compute subtree info on the fly (def. no)\n");
     fprintf(stderr,"\t-x        do not compact new 1's submatrices in the result matrix\n");    
     #endif  
-    fprintf(stderr,"\t-q        use a single copy when squaring a matrix\n");
     fprintf(stderr,"\t-h        show this help message\n");    
     fprintf(stderr,"\t-v        verbose\n\n");
     exit(1);

minimats.c

@@ -267,7 +267,7 @@ void minimat_to_bbm(uint8_t *m, size_t msize, size_t i, size_t j, size_t size, m
 // :size is the size of the minimat :a
 void minimat_to_text(FILE *f, size_t msize, size_t i, size_t j, size_t size, minimat_t a) {
   assert(size==MMsize);
-  assert(i<msize+2*size && j<msize+2*size);
+  assert(i<msize+2*size && j<msize+2*size); // again, why the + 2*size
   for(size_t ii=0; ii<size; ii++)
     for(size_t jj=0; jj<size; jj++)
       if(i+ii<msize && j+jj<msize) {       // inside the matrix

submatrix.py

@@ -43,13 +43,13 @@ do
 
   # testing k2unary.x ie A+0 and A+I
   echo "===== add diagonal to sparse matrix: $f"  
-  $timecmd -f"$tf" ./sparsetr.py -d -o $f.sparse.1 $f
+  $timecmd -f"$tf" util/sparsetr.py -d -o $f.sparse.1 $f
 
   echo "===== compress and check matrix $f in formats k2 and k4"
   $timecmd -f"$tf" ./k2sparse.x -cv -o $f.k2  $f 
   $timecmd -f"$tf" ./k2sparse.x -c -o $f.k4 -m4 $f 
 
-  echo "==== add 0, add I and compute (A+I)^2==="
+  echo "==== add 0, add I and compute (A+I)^2  ==="
   $timecmd -f"$tf" ./k2unary.x -o $f.2  $f.k2 
   $timecmd -f"$tf" ./k2unary.x -o $f.4  $f.k4 
 
@@ -68,10 +68,10 @@ do
 
   # testing k2sum.x A+A^t
   echo "===== transpose sparse matrix: $f"  
-  $timecmd -f"$tf" ./sparsetr.py -t -o sparse.tr $f
+  $timecmd -f"$tf" util/sparsetr.py -t -o sparse.tr $f
   # this is A+A^t = A^t + A
   echo "===== make symmetric sparse matrix: $f"  
-  $timecmd -f"$tf" ./sparsetr.py -S -o sparse.sym $f
+  $timecmd -f"$tf" util/sparsetr.py -S -o sparse.sym $f
 
   echo "===== compress transposed matrix $f in formats k2 and k4"
   $timecmd -f"$tf" ./k2sparse.x -o $f.tr.k2  sparse.tr